Performance-Analyse
Hinweis: Neuer Leiter ab dem 20.08.2015.
Ich habe jede der verschiedenen Konvertierungsmethoden durch einige grobe StopwatchLeistungstests, einen Lauf mit einem zufälligen Satz (n = 61, 1000 Iterationen) und einen Lauf mit einem Projekt-Gutenburg-Text (n = 1.238.957, 150 Iterationen) geführt. Hier sind die Ergebnisse, ungefähr vom schnellsten zum langsamsten. Alle Messungen erfolgen in Ticks ( 10.000 Ticks = 1 ms ) und alle relativen Noten werden mit der [langsamsten] StringBuilderImplementierung verglichen . Informationen zum verwendeten Code finden Sie unten oder im Testframework-Repo, in dem ich jetzt den Code zum Ausführen dieses Codes verwalte.
Haftungsausschluss
WARNUNG: Verlassen Sie sich bei nichts Konkretem auf diese Statistiken. Sie sind einfach ein Beispiellauf von Beispieldaten. Wenn Sie wirklich erstklassige Leistung benötigen, testen Sie diese Methoden in einer Umgebung, die für Ihre Produktionsanforderungen repräsentativ ist, mit Daten, die für Ihre Verwendung repräsentativ sind.
Ergebnisse
- Byte-
unsafeSuche (über CodesInChaos) (hinzugefügt, um das Repo per Luftatmer zu testen )
- Text: 4.727,85 (105,2X)
- Satz: 0,28 (99,7X)
- Bytesuche (über CodesInChaos)
- Text: 10.853,96 (45,8-mal schneller)
- Satz: 0,65 (42,7X schneller)
- Byte-Manipulation 2 (über CodesInChaos)
- Text: 12.967,69 (38,4-mal schneller)
- Satz: 0,73 (37,9X schneller)
- Bytemanipulation (über Waleed Eissa)
- Text: 16.856,64 (29,5-mal schneller)
- Satz: 0,70 (39,5-mal schneller)
- Lookup / Shift (über Nathan Moinvaziri)
- Text: 23.201,23 (21,4-mal schneller)
- Satz: 1,24 (22,3-mal schneller)
- Nachschlagen durch Knabbern (via Brian Lambert)
- Text: 23.879,41 (20,8-mal schneller)
- Satz: 1,15 (23,9X schneller)
BitConverter (über Tomalak)
- Text: 113.269,34 (4,4-mal schneller)
- Satz: 9,98 (2,8-mal schneller)
{SoapHexBinary}.ToString (über Mykroft)
- Text: 178.601,39 (2,8-mal schneller)
- Satz: 10,68 (2,6-mal schneller)
{byte}.ToString("X2")(mit foreach) (abgeleitet von Will Deans Antwort)
- Text: 308.805,38 (2,4-mal schneller)
- Satz: 16,89 (2,4-mal schneller)
{byte}.ToString("X2")(Verwenden von {IEnumerable}.Aggregate, erfordert System.Linq) (über Mark)
- Text: 352.828,20 (2,1-mal schneller)
- Satz: 16,87 (2,4-mal schneller)
Array.ConvertAll(mit string.Join) (über Will Dean)
- Text: 675.451,57 (1,1-fach schneller)
- Satz: 17,95 (2,2-mal schneller)
Array.ConvertAll(Verwendung string.Concatvon .NET 4.0 erforderlich) (über Will Dean)
- Text: 752.078,70 (1,0-mal schneller)
- Satz: 18,28 (2,2-mal schneller)
{StringBuilder}.AppendFormat(mit foreach) (via Tomalak)
- Text: 672.115,77 (1,1-mal schneller)
- Satz: 36,82 (1,1-mal schneller)
{StringBuilder}.AppendFormat(Verwenden von {IEnumerable}.Aggregate, erfordert System.Linq) (abgeleitet von Tomalaks Antwort)
- Text: 718.380,63 (1,0-mal schneller)
- Satz: 39,71 (1,0x schneller)
Nachschlagetabellen haben die Führung bei der Bytemanipulation übernommen. Grundsätzlich gibt es eine Form der Vorberechnung, was ein bestimmtes Halbbyte oder Byte in hexadezimaler Form sein wird. Wenn Sie dann die Daten durchgehen, schauen Sie einfach im nächsten Abschnitt nach, um zu sehen, um welche Hex-Zeichenfolge es sich handelt. Dieser Wert wird dann auf irgendeine Weise zur resultierenden Zeichenfolgenausgabe hinzugefügt. Lange Zeit war die Byte-Manipulation, die von einigen Entwicklern möglicherweise schwerer zu lesen war, der Ansatz mit der besten Leistung.
Am besten finden Sie immer noch einige repräsentative Daten und probieren sie in einer produktionsähnlichen Umgebung aus. Wenn Sie unterschiedliche Speicherbeschränkungen haben, bevorzugen Sie möglicherweise eine Methode mit weniger Zuordnungen gegenüber einer Methode, die schneller ist, aber mehr Speicher verbraucht.
Code testen
Fühlen Sie sich frei, mit dem Testcode zu spielen, den ich verwendet habe. Eine Version ist hier enthalten, aber Sie können das Repo klonen und Ihre eigenen Methoden hinzufügen. Bitte senden Sie eine Pull-Anfrage, wenn Sie etwas Interessantes finden oder zur Verbesserung des verwendeten Test-Frameworks beitragen möchten.
- Fügen Sie die neue statische Methode (
Func<byte[], string>) zu /Tests/ConvertByteArrayToHexString/Test.cs hinzu.
- Fügen Sie den Namen dieser Methode zum
TestCandidatesRückgabewert in derselben Klasse hinzu.
- Stellen Sie sicher, dass Sie die gewünschte Eingabeversion (Satz oder Text) ausführen, indem Sie die Kommentare in
GenerateTestInputderselben Klasse umschalten .
- Drücken Sie F5und warten Sie auf die Ausgabe (ein HTML-Speicherauszug wird auch im Ordner / bin generiert).
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();
}
Update (13.01.2010)
Waleeds Antwort zur Analyse hinzugefügt. Ziemlich schnell.
Update (05.10.2011)
Der string.Concat Array.ConvertAllVollständigkeit halber wurde eine Variante hinzugefügt (erfordert .NET 4.0). Auf Augenhöhe mit der string.JoinVersion.
Update (05.02.2012)
Test Repo enthält weitere Varianten wie StringBuilder.Append(b.ToString("X2")). Keiner hat die Ergebnisse gestört. foreachist schneller als {IEnumerable}.Aggregatezum Beispiel, BitConvertergewinnt aber trotzdem.
Update (03.04.2012)
Mykrofts SoapHexBinaryAntwort zur Analyse hinzugefügt , die den dritten Platz einnahm.
Update (15.01.2013)
Die Byte-Manipulationsantwort von CodesInChaos wurde hinzugefügt, die den ersten Platz einnahm (mit großem Abstand bei großen Textblöcken).
Update (23.05.2013)
Nathan Moinvaziris Lookup-Antwort und die Variante aus Brian Lamberts Blog wurden hinzugefügt. Beides ziemlich schnell, aber nicht die Führung auf der von mir verwendeten Testmaschine (AMD Phenom 9750).
Update (31.07.2014)
Die neue bytebasierte Suchantwort von @ CodesInChaos wurde hinzugefügt. Es scheint sowohl bei den Satztests als auch bei den Volltexttests die Führung übernommen zu haben.
Update (20.08.2015)
Hinzugefügt airbreather die Optimierungen und unsafeVariante dieser Repo - Antwort . Wenn Sie in dem unsicheren Spiel spielen möchten, können Sie sowohl bei kurzen Saiten als auch bei großen Texten enorme Leistungssteigerungen gegenüber den vorherigen Top-Gewinnern erzielen.