Analisi di performance
Nota: nuovo leader dal 20-08-2015.
Ho eseguito ciascuno dei vari metodi di conversione attraverso alcuni Stopwatchtest di prestazione grezzi , una corsa con una frase casuale (n = 61, 1000 iterazioni) e una corsa con un testo di Project Gutenburg (n = 1.238.957, 150 iterazioni). Ecco i risultati, approssimativamente dal più veloce al più lento. Tutte le misurazioni sono in tick ( 10.000 tick = 1 ms ) e tutte le note relative vengono confrontate con l' StringBuilderimplementazione [più lenta] . Per il codice utilizzato, vedere di seguito o il repository del framework di test in cui ora mantengo il codice per l'esecuzione.
disconoscimento
ATTENZIONE: non fare affidamento su queste statistiche per qualcosa di concreto; sono semplicemente una serie di dati campione. Se hai davvero bisogno di prestazioni di altissimo livello, prova questi metodi in un ambiente rappresentativo delle tue esigenze di produzione con i dati rappresentativi di ciò che utilizzerai.
risultati
- Ricerca per byte
unsafe(tramite CodesInChaos) (aggiunta al repository di prova tramite airbreather )
- Testo: 4.727,85 (105.2X)
- Frase: 0,28 (99,7X)
- Ricerca per byte (tramite CodesInChaos)
- Testo: 10.853,96 (45.8 volte più veloce)
- Frase: 0,65 (42,7 volte più veloce)
- Byte Manipulation 2 (tramite CodesInChaos)
- Testo: 12.967,69 (38,4 volte più veloce)
- Frase: 0,73 (37,9 volte più veloce)
- Manipolazione dei byte (via Waleed Eissa)
- Testo: 16.856,64 (29,5 volte più veloce)
- Frase: 0,70 (39,5 volte più veloce)
- Ricerca / Maiusc (via Nathan Moinvaziri)
- Testo: 23.201,23 (21,4 volte più veloce)
- Frase: 1,24 (22,3 volte più veloce)
- Ricerca per nibble (via Brian Lambert)
- Testo: 23.879,41 (20,8 volte più veloce)
- Frase: 1,15 (23,9 volte più veloce)
BitConverter (via Tomalak)
- Testo: 113.269,34 (4,4 volte più veloce)
- Frase: 9,98 (2,8 volte più veloce)
{SoapHexBinary}.ToString (tramite Mykroft)
- Testo: 178.601,39 (2,8 volte più veloce)
- Frase: 10,68 (2,6 volte più veloce)
{byte}.ToString("X2")(usando foreach) (derivato dalla risposta di Will Dean)
- Testo: 308.805,38 (2,4 volte più veloce)
- Frase: 16,89 (2,4 volte più veloce)
{byte}.ToString("X2")(utilizzando {IEnumerable}.Aggregate, richiede System.Linq) (tramite Mark)
- Testo: 352.828,20 (2.1 volte più veloce)
- Frase: 16,87 (2,4 volte più veloce)
Array.ConvertAll(utilizzando string.Join) (tramite Will Dean)
- Testo: 675.451,57 (1.1X più veloce)
- Frase: 17,95 (2,2 volte più veloce)
Array.ConvertAll(utilizzando string.Concat, richiede .NET 4.0) (tramite Will Dean)
- Testo: 752.078,70 (1,0 volte più veloce)
- Frase: 18,28 (2,2 volte più veloce)
{StringBuilder}.AppendFormat(utilizzando foreach) (tramite Tomalak)
- Testo: 672.115,77 (1.1X più veloce)
- Frase: 36,82 (1,1 volte più veloce)
{StringBuilder}.AppendFormat(usando {IEnumerable}.Aggregate, richiede System.Linq) (derivato dalla risposta di Tomalak)
- Testo: 718.380,63 (1,0 volte più veloce)
- Frase: 39,71 (1,0 volte più veloce)
Le tabelle di ricerca hanno preso il comando della manipolazione dei byte. Fondamentalmente, esiste una qualche forma di pre-calcolo di ciò che qualsiasi dato bocconcino o byte sarà in esadecimale. Quindi, mentre si sfogliano i dati, è sufficiente cercare la parte successiva per vedere quale stringa esadecimale sarebbe. Tale valore viene quindi aggiunto all'output della stringa risultante in qualche modo. Per molto tempo la manipolazione dei byte, potenzialmente più difficile da leggere per alcuni sviluppatori, è stata l'approccio più performante.
La tua scommessa migliore sarà ancora trovare alcuni dati rappresentativi e provarli in un ambiente simile alla produzione. Se hai diversi vincoli di memoria, potresti preferire un metodo con meno allocazioni a uno che sarebbe più veloce ma consuma più memoria.
Codice test
Sentiti libero di giocare con il codice di test che ho usato. Una versione è inclusa qui, ma sentiti libero di clonare il repository e aggiungere i tuoi metodi. Invia una richiesta pull se trovi qualcosa di interessante o desideri contribuire a migliorare il framework di test che utilizza.
- Aggiungi il nuovo metodo statico (
Func<byte[], string> ) a /Tests/ConvertByteArrayToHexString/Test.cs.
- Aggiungi il nome di quel metodo a
TestCandidates valore restituito nella stessa classe.
- Assicurati di eseguire la versione di input desiderata, frase o testo, attivando i commenti
GenerateTestInput in quella stessa classe.
- Premi F5e attendi l'output (nella cartella / bin viene generato anche un dump HTML).
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();
}
Aggiornamento (13/01/2010)
Aggiunta la risposta di Waleed all'analisi. Abbastanza veloce.
Aggiornamento (2011-10-05)
Aggiunta string.Concat Array.ConvertAllvariante per completezza (richiede .NET 4.0). Alla pari constring.Join versione.
Aggiornamento (05/02/2012)
Il repository di prova include più varianti come StringBuilder.Append(b.ToString("X2")). Nessuno ha stravolto i risultati. foreachè più veloce di {IEnumerable}.Aggregate, per esempio, ma BitConvertervince ancora.
Aggiornamento (03-04-2012)
Aggiunto Mykroft SoapHexBinary risposta all'analisi, che ha preso il terzo posto.
Aggiornamento (15-01-2013)
Aggiunta la risposta alla manipolazione dei byte di CodesInChaos, che ha preso il primo posto (con un ampio margine su grandi blocchi di testo).
Aggiornamento (23/05/2013)
Aggiunta la risposta di ricerca di Nathan Moinvaziri e la variante dal blog di Brian Lambert. Entrambi piuttosto veloci, ma non prendendo il comando sulla macchina di prova che ho usato (AMD Phenom 9750).
Aggiornamento (2014-07-31)
Aggiunta la nuova risposta di ricerca basata su byte di @ CodesInChaos. Sembra aver preso il comando sia per i test delle frasi che per i test full-text.
Aggiornamento (20-08-2015)
Aggiunte ottimizzazioni e varianti di airbreather al repository diunsafe questa risposta . Se vuoi giocare in un gioco non sicuro, puoi ottenere enormi guadagni in termini di prestazioni rispetto a tutti i precedenti vincitori su stringhe brevi e testi di grandi dimensioni.