Análise de desempenho
Nota: novo líder a partir de 20/08/2015.
Eu executei cada um dos vários métodos de conversão por meio de alguns Stopwatchtestes de desempenho bruto , uma execução com uma sentença aleatória (n = 61, 1000 iterações) e uma execução com um texto do Project Gutenburg (n = 1.238.957, 150 iterações). Aqui estão os resultados, aproximadamente do mais rápido para o mais lento. Todas as medidas estão em ticks ( 10.000 ticks = 1 ms ) e todas as notas relativas são comparadas com a StringBuilderimplementação [mais lenta] . Para o código usado, veja abaixo ou o repositório da estrutura de teste, onde agora mantenho o código para executar isso.
aviso Legal
AVISO: Não confie nessas estatísticas para nada concreto; eles são simplesmente uma amostra de dados de amostra. Se você realmente precisa de desempenho de alto nível, teste esses métodos em um ambiente representativo de suas necessidades de produção com dados representativos do que você usará.
Resultados
- Pesquisa por byte
unsafe(via CodesInChaos) (adicionada ao repositório de teste pelo respirador de ar )
- Texto: 4.727,85 (105,2X)
- Sentença: 0,28 (99,7X)
- Pesquisa por byte (via CodesInChaos)
- Texto: 10.853,96 (45,8X mais rápido)
- Sentença: 0,65 (42,7X mais rápido)
- Manipulação de bytes 2 (via CodesInChaos)
- Texto: 12.967,69 (38,4X mais rápido)
- Sentença: 0,73 (37,9X mais rápido)
- Manipulação de bytes (via Waleed Eissa)
- Texto: 16.856,64 (29,5X mais rápido)
- Sentença: 0,70 (39,5X mais rápido)
- Pesquisa / Mudança (via Nathan Moinvaziri)
- Texto: 23.201.23 (21.4X mais rápido)
- Sentença: 1,24 (22,3X mais rápido)
- Pesquisa por nibble (via Brian Lambert)
- Texto: 23.879,41 (20,8X mais rápido)
- Sentença: 1,15 (23,9X mais rápido)
BitConverter (via Tomalak)
- Texto: 113.269,34 (4,4X mais rápido)
- Sentença: 9,98 (2,8X mais rápido)
{SoapHexBinary}.ToString (via Mykroft)
- Texto: 178.601,39 (2,8X mais rápido)
- Sentença: 10.68 (2.6X mais rápido)
{byte}.ToString("X2")(using foreach) (derivado da resposta de Will Dean)
- Texto: 308.805,38 (2,4X mais rápido)
- Sentença: 16,89 (2,4X mais rápido)
{byte}.ToString("X2")(usando {IEnumerable}.Aggregate, requer System.Linq) (via Mark)
- Texto: 352.828,20 (2,1X mais rápido)
- Sentença: 16,87 (2,4X mais rápido)
Array.ConvertAll(usando string.Join) (via Will Dean)
- Texto: 675.451,57 (1,1X mais rápido)
- Sentença: 17,95 (2,2X mais rápido)
Array.ConvertAll(usando string.Concat, requer .NET 4.0) (via Will Dean)
- Texto: 752.078,70 (1,0X mais rápido)
- Sentença: 18.28 (2.2X mais rápido)
{StringBuilder}.AppendFormat(usando foreach) (via Tomalak)
- Texto: 672.115,77 (1,1X mais rápido)
- Sentença: 36,82 (1,1X mais rápido)
{StringBuilder}.AppendFormat(usando {IEnumerable}.Aggregate, requer System.Linq) (derivado da resposta de Tomalak)
- Texto: 718.380,63 (1,0X mais rápido)
- Sentença: 39,71 (1,0X mais rápido)
As tabelas de pesquisa assumiram a liderança na manipulação de bytes. Basicamente, existe alguma forma de pré-computar o que qualquer mordidela ou byte será em hexadecimal. Então, conforme você percorre os dados, basta procurar a próxima parte para ver qual seria a sequência hexadecimal. Esse valor é então adicionado à saída resultante da string de alguma maneira. Por um longo tempo, a manipulação de bytes, potencialmente mais difícil de ler por alguns desenvolvedores, foi a abordagem de melhor desempenho.
Sua melhor aposta ainda será encontrar alguns dados representativos e testá-los em um ambiente semelhante à produção. Se você tiver restrições de memória diferentes, poderá preferir um método com menos alocações a um método que seria mais rápido, mas consumiria mais memória.
Código de teste
Sinta-se livre para jogar com o código de teste que eu usei. Uma versão está incluída aqui, mas fique à vontade para clonar o repositório e adicionar seus próprios métodos. Envie uma solicitação pull se encontrar algo interessante ou quiser ajudar a melhorar a estrutura de teste usada.
- Adicione o novo método estático (
Func<byte[], string>) a /Tests/ConvertByteArrayToHexString/Test.cs.
- Adicione o nome desse método ao
TestCandidatesvalor de retorno na mesma classe.
- Verifique se você está executando a versão de entrada desejada, frase ou texto, alternando os comentários na
GenerateTestInputmesma classe.
- Pressione F5e aguarde a saída (um despejo de HTML também é gerado na pasta / 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();
}
Atualização (13-01-2010)
Adicionada a resposta de Waleed à análise. Muito rápido.
Atualização (05/10/2011)
string.Concat Array.ConvertAllVariante adicionada para completude (requer .NET 4.0). A par da string.Joinversão.
Atualização (05-02-2012)
O repositório de teste inclui mais variantes, como StringBuilder.Append(b.ToString("X2")). Nenhum perturbou os resultados. foreaché mais rápido do que {IEnumerable}.Aggregate, por exemplo, mas BitConverterainda ganha.
Atualização (03/04/2012)
Adicionada a SoapHexBinaryresposta de Mykroft à análise, que assumiu o terceiro lugar.
Atualização (15/01/2013)
Adicionada a resposta de manipulação de bytes do CodesInChaos, que assumiu o primeiro lugar (por uma grande margem em grandes blocos de texto).
Atualização (23-05-2013)
Adicionada a resposta de pesquisa de Nathan Moinvaziri e a variante do blog de Brian Lambert. Ambos bastante rápidos, mas não assumindo a liderança na máquina de teste que usei (AMD Phenom 9750).
Atualização (31-07-2014)
Adicionada a nova resposta de pesquisa baseada em byte do @ CodesInChaos. Parece ter assumido a liderança nos testes de sentenças e nos testes de texto completo.
Atualização (20/08/2015)
Adicionadas otimizações e variantes do respirador de ar ao repositóriounsafe desta resposta . Se você quiser jogar no jogo inseguro, poderá obter enormes ganhos de desempenho em relação a qualquer um dos vencedores anteriores, tanto em textos curtos quanto em textos grandes.