Análisis de rendimiento
Nota: nuevo líder a partir del 2015-08-20.
Ejecuté cada uno de los diversos métodos de conversión a través de algunas Stopwatchpruebas de rendimiento en bruto , una ejecución con una oración aleatoria (n = 61, 1000 iteraciones) y una ejecución con un texto del Proyecto Gutenburg (n = 1,238,957, 150 iteraciones). Aquí están los resultados, aproximadamente del más rápido al más lento. Todas las mediciones están en ticks ( 10,000 ticks = 1 ms ) y todas las notas relativas se comparan con la StringBuilderimplementación [más lenta] . Para el código utilizado, vea a continuación o el repositorio de marco de prueba donde ahora mantengo el código para ejecutar esto.
Descargo de responsabilidad
ADVERTENCIA: No confíe en estas estadísticas para nada concreto; son simplemente una muestra de datos de muestra. Si realmente necesita un rendimiento de primer nivel, pruebe estos métodos en un entorno representativo de sus necesidades de producción con datos representativos de lo que utilizará.
Resultados
- Lookup por byte
unsafe(a través de CodesInChaos) (añadido a repo prueba por airbreather )
- Texto: 4,727.85 (105.2X)
- Oración: 0.28 (99.7X)
- Búsqueda por byte (a través de CodesInChaos)
- Texto: 10,853.96 (45.8X más rápido)
- Oración: 0.65 (42.7X más rápido)
- Byte Manipulation 2 (a través de CodesInChaos)
- Texto: 12,967.69 (38.4X más rápido)
- Oración: 0,73 (37,9 veces más rápido)
- Manipulación de bytes (a través de Waleed Eissa)
- Texto: 16,856.64 (29.5X más rápido)
- Oración: 0.70 (39.5X más rápido)
- Búsqueda / cambio (a través de Nathan Moinvaziri)
- Texto: 23,201.23 (21.4X más rápido)
- Oración: 1.24 (22.3X más rápido)
- Búsqueda por mordisco (a través de Brian Lambert)
- Texto: 23,879.41 (20.8X más rápido)
- Oración: 1.15 (23.9X más rápido)
BitConverter (a través de Tomalak)
- Texto: 113,269.34 (4.4X más rápido)
- Oración: 9.98 (2.8 veces más rápido)
{SoapHexBinary}.ToString (a través de Mykroft)
- Texto: 178,601.39 (2.8 veces más rápido)
- Oración: 10.68 (2.6 veces más rápido)
{byte}.ToString("X2")(usando foreach) (derivado de la respuesta de Will Dean)
- Texto: 308,805.38 (2.4 veces más rápido)
- Oración: 16,89 (2,4 veces más rápido)
{byte}.ToString("X2")(usando {IEnumerable}.Aggregate, requiere System.Linq) (a través de Mark)
- Texto: 352,828.20 (2.1 veces más rápido)
- Oración: 16,87 (2,4 veces más rápido)
Array.ConvertAll(usando string.Join) (a través de Will Dean)
- Texto: 675,451.57 (1.1X más rápido)
- Sentencia: 17.95 (2.2 veces más rápido)
Array.ConvertAll(usando string.Concat, requiere .NET 4.0) (a través de Will Dean)
- Texto: 752,078.70 (1.0X más rápido)
- Oración: 18.28 (2.2 veces más rápido)
{StringBuilder}.AppendFormat(usando foreach) (a través de Tomalak)
- Texto: 672,115.77 (1.1X más rápido)
- Oración: 36.82 (1.1X más rápido)
{StringBuilder}.AppendFormat(usando {IEnumerable}.Aggregate, requiere System.Linq) (derivado de la respuesta de Tomalak)
- Texto: 718,380.63 (1.0X más rápido)
- Oración: 39.71 (1.0X más rápido)
Las tablas de búsqueda han tomado la delantera sobre la manipulación de bytes. Básicamente, hay alguna forma de precomputar lo que cualquier mordisco o byte dado estará en hexadecimal. Luego, mientras revisa los datos, simplemente busca la siguiente porción para ver qué cadena hexadecimal sería. Ese valor se agrega a la salida de cadena resultante de alguna manera. Durante mucho tiempo, la manipulación de bytes, potencialmente más difícil de leer por algunos desarrolladores, fue el enfoque de mayor rendimiento.
Su mejor opción será encontrar algunos datos representativos y probarlos en un entorno similar a la producción. Si tiene diferentes restricciones de memoria, puede preferir un método con menos asignaciones a uno que sea más rápido pero consuma más memoria.
Código de prueba
Siéntase libre de jugar con el código de prueba que utilicé. Aquí se incluye una versión, pero puede clonar el repositorio y agregar sus propios métodos. Envíe una solicitud de extracción si encuentra algo interesante o desea ayudar a mejorar el marco de prueba que utiliza.
- Agregue el nuevo método estático (
Func<byte[], string>) a /Tests/ConvertByteArrayToHexString/Test.cs.
- Agregue el nombre de ese método al
TestCandidatesvalor de retorno en esa misma clase.
- Asegúrese de estar ejecutando la versión de entrada que desea, oración o texto, alternando los comentarios
GenerateTestInputen esa misma clase.
- Presione F5y espere la salida (también se genera un volcado de HTML en la carpeta / bin).
static string ByteArrayToHexStringViaStringJoinArrayConvertAll(byte[] bytes) {
return string.Join(string.Empty, Array.ConvertAll(bytes, b => b.ToString("X2")));
}
static string ByteArrayToHexStringViaStringConcatArrayConvertAll(byte[] bytes) {
return string.Concat(Array.ConvertAll(bytes, b => b.ToString("X2")));
}
static string ByteArrayToHexStringViaBitConverter(byte[] bytes) {
string hex = BitConverter.ToString(bytes);
return hex.Replace("-", "");
}
static string ByteArrayToHexStringViaStringBuilderAggregateByteToString(byte[] bytes) {
return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.Append(b.ToString("X2"))).ToString();
}
static string ByteArrayToHexStringViaStringBuilderForEachByteToString(byte[] bytes) {
StringBuilder hex = new StringBuilder(bytes.Length * 2);
foreach (byte b in bytes)
hex.Append(b.ToString("X2"));
return hex.ToString();
}
static string ByteArrayToHexStringViaStringBuilderAggregateAppendFormat(byte[] bytes) {
return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.AppendFormat("{0:X2}", b)).ToString();
}
static string ByteArrayToHexStringViaStringBuilderForEachAppendFormat(byte[] bytes) {
StringBuilder hex = new StringBuilder(bytes.Length * 2);
foreach (byte b in bytes)
hex.AppendFormat("{0:X2}", b);
return hex.ToString();
}
static string ByteArrayToHexViaByteManipulation(byte[] bytes) {
char[] c = new char[bytes.Length * 2];
byte b;
for (int i = 0; i < bytes.Length; i++) {
b = ((byte)(bytes[i] >> 4));
c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
b = ((byte)(bytes[i] & 0xF));
c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
}
return new string(c);
}
static string ByteArrayToHexViaByteManipulation2(byte[] bytes) {
char[] c = new char[bytes.Length * 2];
int b;
for (int i = 0; i < bytes.Length; i++) {
b = bytes[i] >> 4;
c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7));
b = bytes[i] & 0xF;
c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7));
}
return new string(c);
}
static string ByteArrayToHexViaSoapHexBinary(byte[] bytes) {
SoapHexBinary soapHexBinary = new SoapHexBinary(bytes);
return soapHexBinary.ToString();
}
static string ByteArrayToHexViaLookupAndShift(byte[] bytes) {
StringBuilder result = new StringBuilder(bytes.Length * 2);
string hexAlphabet = "0123456789ABCDEF";
foreach (byte b in bytes) {
result.Append(hexAlphabet[(int)(b >> 4)]);
result.Append(hexAlphabet[(int)(b & 0xF)]);
}
return result.ToString();
}
static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_Lookup32, GCHandleType.Pinned).AddrOfPinnedObject();
static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes) {
var lookupP = _lookup32UnsafeP;
var result = new string((char)0, bytes.Length * 2);
fixed (byte* bytesP = bytes)
fixed (char* resultP = result) {
uint* resultP2 = (uint*)resultP;
for (int i = 0; i < bytes.Length; i++) {
resultP2[i] = lookupP[bytesP[i]];
}
}
return result;
}
static uint[] _Lookup32 = Enumerable.Range(0, 255).Select(i => {
string s = i.ToString("X2");
return ((uint)s[0]) + ((uint)s[1] << 16);
}).ToArray();
static string ByteArrayToHexViaLookupPerByte(byte[] bytes) {
var result = new char[bytes.Length * 2];
for (int i = 0; i < bytes.Length; i++)
{
var val = _Lookup32[bytes[i]];
result[2*i] = (char)val;
result[2*i + 1] = (char) (val >> 16);
}
return new string(result);
}
static string ByteArrayToHexViaLookup(byte[] bytes) {
string[] hexStringTable = new string[] {
"00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F",
"10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B", "1C", "1D", "1E", "1F",
"20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F",
"30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C", "3D", "3E", "3F",
"40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4A", "4B", "4C", "4D", "4E", "4F",
"50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D", "5E", "5F",
"60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6A", "6B", "6C", "6D", "6E", "6F",
"70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E", "7F",
"80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8A", "8B", "8C", "8D", "8E", "8F",
"90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F",
"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF",
"B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF",
"C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF",
"D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF",
"E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF",
"F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF",
};
StringBuilder result = new StringBuilder(bytes.Length * 2);
foreach (byte b in bytes) {
result.Append(hexStringTable[b]);
}
return result.ToString();
}
Actualización (2010-01-13)
Se agregó la respuesta de Waleed al análisis. Bastante rapido.
Actualización (2011-10-05)
string.Concat Array.ConvertAllVariante agregada para completar (requiere .NET 4.0). A la par destring.Join versión.
Actualización (2012-02-05)
El repositorio de prueba incluye más variantes como StringBuilder.Append(b.ToString("X2")). Ninguno alteró los resultados. foreaches más rápido que {IEnumerable}.Aggregate, por ejemplo, pero BitConverteraún así gana.
Actualización (2012-04-03)
Se agregó la SoapHexBinaryrespuesta de Mykroft al análisis, que tomó el tercer lugar.
Actualización (2013-01-15)
Se agregó la respuesta de manipulación de bytes de CodesInChaos, que ocupó el primer lugar (por un gran margen en grandes bloques de texto).
Actualización (2013-05-23)
Se agregó la respuesta de búsqueda de Nathan Moinvaziri y la variante del blog de Brian Lambert. Ambos bastante rápido, pero sin tomar la iniciativa en la máquina de prueba que utilicé (AMD Phenom 9750).
Actualización (2014-07-31)
Se agregó la nueva respuesta de búsqueda basada en bytes de @ CodesInChaos. Parece haber tomado la delantera tanto en las pruebas de oraciones como en las pruebas de texto completo.
Actualización (2015-08-20)
Se agregaron optimizaciones y unsafevariantes de airbreather al repositorio de esta respuesta . Si quieres jugar en el juego inseguro, puedes obtener grandes ganancias de rendimiento sobre cualquiera de los ganadores principales anteriores tanto en cadenas cortas como en textos grandes.