Как преобразовать байтовый массив в шестнадцатеричную строку и наоборот?

Как можно преобразовать байтовый массив в шестнадцатеричную строку и наоборот?

Или:

public static string ByteArrayToString(byte[] ba)
{
  StringBuilder hex = new StringBuilder(ba.Length * 2);
  foreach (byte b in ba)
    hex.AppendFormat("{0:x2}", b);
  return hex.ToString();
}

или:

public static string ByteArrayToString(byte[] ba)
{
  return BitConverter.ToString(ba).Replace("-","");
}

Есть еще больше вариантов сделать это, например, здесь .

Обратное преобразование будет выглядеть так:

public static byte[] StringToByteArray(String hex)
{
  int NumberChars = hex.Length;
  byte[] bytes = new byte[NumberChars / 2];
  for (int i = 0; i < NumberChars; i += 2)
    bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
  return bytes;
}

Использование Substring- лучший вариант в сочетании с Convert.ToByte. Смотрите этот ответ для получения дополнительной информации. Если вам нужна лучшая производительность, вы должны избегать, Convert.ToByteпрежде чем вы можете упасть SubString.

Анализ производительности

Примечание: новый лидер с 2015-08-20.

Я проверил каждый из различных методов преобразования через некоторое грубое Stopwatchтестирование производительности, прогон со случайным предложением (n = 61, 1000 итераций) и прогон с текстом Project Gutenburg (n = 1 238 957, 150 итераций). Вот результаты, примерно от самого быстрого до самого медленного. Все измерения даны в тиках ( 10000 тиков = 1 мс ), и все относительные ноты сравниваются с [самой медленной] StringBuilderреализацией. Используемый код см. Ниже или в репозитории тестовой инфраструктуры, где я сейчас поддерживаю код для запуска этого.

отказ

ВНИМАНИЕ: не полагайтесь на эти характеристики для чего-то конкретного; это просто пример пробных данных. Если вам действительно нужна первоклассная производительность, протестируйте эти методы в среде, представляющей ваши производственные потребности, с данными, указывающими, что вы будете использовать.

Результаты

• Поиск по байту unsafe(через CodesInChaos) (добавлен в тестовое репо airbreather )
  • Текст: 4727,85 (105,2X)
  • Приговор: 0,28 (99,7X)
• Поиск по байту (через CodesInChaos)
  • Текст: 10 853,96 (в 45,8 раза быстрее)
  • Предложение: 0,65 (в 42,7 раза быстрее)
• Байтовая манипуляция 2 (через CodesInChaos)
  • Текст: 12 967,69 (в 38,4 раза быстрее)
  • Приговор: 0,73 (37,9X быстрее)
• Байтовая манипуляция (через Валида Эйссу)
  • Текст: 16 856,64 (в 29,5 раз быстрее)
  • Предложение: 0,70 (39,5X быстрее)
• Lookup / Shift (через Натана Моинвазири)
  • Текст: 23,201.23 (в 21,4 раза быстрее)
  • Приговор: 1,24 (в 22,3 раза быстрее)
• Поиск по клеву (через Брайана Ламберта)
  • Текст: 23 879,41 (в 20,8 раза быстрее)
  • Приговор: 1,15 (в 23,9 раза быстрее)
• BitConverter (через Томалак)
  • Текст: 113 269,34 (в 4,4 раза быстрее)
  • Приговор: 9,98 (в 2,8 раза быстрее)
• {SoapHexBinary}.ToString (через Майкрофт)
  • Текст: 178 601,39 (в 2,8 раза быстрее)
  • Предложение: 10,68 (в 2,6 раза быстрее)
• {byte}.ToString("X2")(используя foreach) (получено из ответа Уилла Дина)
  • Текст: 308 805,38 (в 2,4 раза быстрее)
  • Приговор: 16,89 (в 2,4 раза быстрее)
• {byte}.ToString("X2")(используя {IEnumerable}.Aggregate, требует System.Linq) (через Марк)
  • Текст: 352 828,20 (в 2,1 раза быстрее)
  • Приговор: 16,87 (в 2,4 раза быстрее)
• Array.ConvertAll(используя string.Join) (через Уилла Дина)
  • Текст: 675 451,57 (в 1,1 раза быстрее)
  • Приговор: 17,95 (в 2,2 раза быстрее)
• Array.ConvertAll(используется string.Concat, требуется .NET 4.0) (через Уилла Дина)
  • Текст: 752 078,70 (в 1,0 раза быстрее)
  • Приговор: 18,28 (в 2,2 раза быстрее)
• {StringBuilder}.AppendFormat(используя foreach) (через Томалак)
  • Текст: 672 115,77 (в 1,1 раза быстрее)
  • Приговор: 36,82 (в 1,1 раза быстрее)
• {StringBuilder}.AppendFormat(использование {IEnumerable}.Aggregate, требует System.Linq) (получено из ответа Томалака)
  • Текст: 718 380,63 (в 1,0 раза быстрее)
  • Приговор: 39,71 (в 1,0 раза быстрее)

Таблицы поиска взяли на себя инициативу по манипулированию байтами. По сути, существует некоторая форма предварительного вычисления того, какой любой данный клев или байт будет в шестнадцатеричном виде. Затем, просматривая данные, вы просто просматриваете следующую часть, чтобы увидеть, какой это будет шестнадцатеричная строка. Это значение затем добавляется к полученному выводу строки некоторым способом. Долгое время манипулирование байтами, потенциально трудное для чтения некоторыми разработчиками, было наиболее эффективным подходом.

Ваша лучшая ставка по-прежнему будет найти некоторые репрезентативные данные и опробовать их в производственной среде. Если у вас разные ограничения памяти, вы можете предпочесть метод с меньшим количеством выделений, чем метод, который был бы быстрее, но потреблял бы больше памяти.

Код тестирования

Не стесняйтесь играть с кодом тестирования, который я использовал. Версия включена здесь, но не стесняйтесь клонировать репо и добавлять свои собственные методы. Пожалуйста, отправьте запрос на удаление, если вы найдете что-нибудь интересное или хотите помочь улучшить используемую им инфраструктуру тестирования.

1. Добавьте новый статический метод ( Func<byte[], string>) в /Tests/ConvertByteArrayToHexString/Test.cs.
2. Добавьте имя этого метода к TestCandidatesвозвращаемому значению в том же классе.
3. Убедитесь, что вы используете нужную вам версию ввода, предложение или текст, переключая комментарии GenerateTestInputв том же классе.
4. Нажмите F5и дождитесь вывода (дамп HTML также генерируется в папке / 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();
}

Обновление (2010-01-13)

Добавлен ответ Валида на анализ. Довольно быстро.

Обновление (2011-10-05)

Добавлен string.Concat Array.ConvertAllвариант для полноты (требуется .NET 4.0). Наравне с string.Joinверсией.

Обновление (2012-02-05)

Тест репо включает в себя больше вариантов, таких как StringBuilder.Append(b.ToString("X2")). Никто не расстроил результаты какие-либо. foreachбыстрее, чем {IEnumerable}.Aggregate, например, но BitConverterвсе же выигрывает.

Обновление (2012-04-03)

В SoapHexBinaryанализ добавлен ответ Майкрофта , который занял третье место.

Обновление (2013-01-15)

Добавлен ответ CodesInChaos по манипулированию байтами, который занял первое место (с большим запасом для больших блоков текста).

Обновление (2013-05-23)

Добавлен ответ поиска Натана Моинвазири и вариант из блога Брайана Ламберта. Оба довольно быстрые, но не идут впереди на тестовой машине, которую я использовал (AMD Phenom 9750).

Обновление (2014-07-31)

Добавлен новый байтовый ответ @ CodesInChaos. Похоже, что он взял на себя инициативу как по тестам предложений, так и по полнотекстовым тестам.

Обновление (2015-08-20)

Добавлены оптимизации и варианты airbreatherunsafe к репо этого ответа . Если вы хотите играть в небезопасную игру, вы можете получить огромный выигрыш в производительности по сравнению с любым из предыдущих лучших победителей как в коротких строках, так и в больших текстах.

Есть класс с именем SoapHexBinary, который делает именно то, что вы хотите.

using System.Runtime.Remoting.Metadata.W3cXsd2001;

public static byte[] GetStringToBytes(string value)
{
    SoapHexBinary shb = SoapHexBinary.Parse(value);
    return shb.Value;
}

public static string GetBytesToString(byte[] value)
{
    SoapHexBinary shb = new SoapHexBinary(value);
    return shb.ToString();
}

При написании крипто-кода обычно избегают зависимых от данных ветвей и поиска таблиц, чтобы гарантировать, что время выполнения не зависит от данных, поскольку зависящее от данных время может привести к атакам по побочным каналам.

Это также довольно быстро.

static string ByteToHexBitFiddle(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);
}

_{Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn}

Оставь всякую надежду, вы, кто входит сюда

Объяснение странной мелочи:

1. bytes[i] >> 4извлекает верхний кусок байта
   bytes[i] & 0xFизвлекает нижний кусок байта
2. b - 10
   это < 0для значений b < 10, которые станут десятичной цифрой
   является >= 0для значений b > 10, которые станут письмом от Aдо F.
3. Использование i >> 3132-разрядного целого числа со знаком извлекает знак благодаря расширению знака. Это будет -1для i < 0и 0для i >= 0.
4. Объединяя 2) и 3), показывает, что (b-10)>>31будет 0для букв и -1цифр.
5. Если посмотреть на регистр букв, последнее слагаемое становится 0и bнаходится в диапазоне от 10 до 15. Мы хотим сопоставить его с A(65) - F(70), что подразумевает добавление 55 ( 'A'-10).
6. Рассматривая случай цифр, мы хотим адаптировать последнее слагаемое, чтобы оно отображалось bв диапазоне от 0 до 9 с диапазоном 0(48) - 9(57). Это означает, что он должен стать -7 ( '0' - 55).
   Теперь мы можем просто умножить на 7. Но так как -1 представлен всеми битами, равными 1, мы можем вместо этого использовать & -7с (0 & -7) == 0и (-1 & -7) == -7.

Некоторые дальнейшие соображения:

• Я не использовал вторую переменную цикла для индексации c, так как измерения показывают, что вычислять ее iпо более низкой цене.
• Использование именно i < bytes.Lengthверхней границы цикла позволяет JITter исключать проверки границ bytes[i], поэтому я выбрал этот вариант.
• Создание bint позволяет ненужные преобразования от и до байта.

Если вам нужна большая гибкость, чем BitConverterэти неуклюжие явные циклы в стиле 1990-х годов, но вы не можете:

String.Join(String.Empty, Array.ConvertAll(bytes, x => x.ToString("X2")));

Или, если вы используете .NET 4.0:

String.Concat(Array.ConvertAll(bytes, x => x.ToString("X2")));

(Последнее из комментария к оригинальному сообщению.)

Еще один подход на основе таблицы поиска. Этот использует только одну таблицу поиска для каждого байта вместо таблицы поиска для каждого куска.

private static readonly uint[] _lookup32 = CreateLookup32();

private static uint[] CreateLookup32()
{
    var result = new uint[256];
    for (int i = 0; i < 256; i++)
    {
        string s=i.ToString("X2");
        result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
    }
    return result;
}

private static string ByteArrayToHexViaLookup32(byte[] bytes)
{
    var lookup32 = _lookup32;
    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);
}

Я также протестировал варианты этого использования ushort, struct{char X1, X2}, struct{byte X1, X2}в справочной таблице.

В зависимости от цели компиляции (x86, X64) они либо имели примерно одинаковую производительность, либо были немного медленнее, чем этот вариант.

И для еще более высокой производительности, его unsafeродной брат:

private static readonly uint[] _lookup32Unsafe = CreateLookup32Unsafe();
private static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_lookup32Unsafe,GCHandleType.Pinned).AddrOfPinnedObject();

private static uint[] CreateLookup32Unsafe()
{
    var result = new uint[256];
    for (int i = 0; i < 256; i++)
    {
        string s=i.ToString("X2");
        if(BitConverter.IsLittleEndian)
            result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
        else
            result[i] = ((uint)s[1]) + ((uint)s[0] << 16);
    }
    return result;
}

public static string ByteArrayToHexViaLookup32Unsafe(byte[] bytes)
{
    var lookupP = _lookup32UnsafeP;
    var result = new char[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 new string(result);
}

Или, если вы считаете приемлемым писать в строку напрямую:

public 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;
}

Вы можете использовать метод BitConverter.ToString:

byte[] bytes = {0, 1, 2, 4, 8, 16, 32, 64, 128, 256}
Console.WriteLine( BitConverter.ToString(bytes));

Вывод:

00-01-02-04-08-10-20-40-80-FF

Дополнительная информация: метод BitConverter.ToString (Byte [])

Я только что столкнулся с той же проблемой сегодня, и я наткнулся на этот код:

private static string ByteArrayToHex(byte[] barray)
{
    char[] c = new char[barray.Length * 2];
    byte b;
    for (int i = 0; i < barray.Length; ++i)
    {
        b = ((byte)(barray[i] >> 4));
        c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
        b = ((byte)(barray[i] & 0xF));
        c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
    }
    return new string(c);
}

Источник: сообщение на форуме byte [] Array to Hex String (см. Сообщение PZahra). Я немного изменил код, чтобы удалить префикс 0x.

Я провел некоторое тестирование производительности в коде, и это было почти в восемь раз быстрее, чем при использовании BitConverter.ToString () (самый быстрый согласно сообщению Патриджа).

Это ответ на пересмотр 4 из весьма популярного ответа Томалак в (и последующих правок).

Я сделаю так, что это редактирование неверно, и объясню, почему оно может быть отменено. Попутно вы можете узнать кое-что о некоторых внутренних элементах и ​​увидеть еще один пример того, что такое преждевременная оптимизация и как она может вас укусить.

tl; dr: Просто используйте, Convert.ToByteи String.Substringесли вы спешите («Оригинальный код» ниже), то это лучшая комбинация, если вы не хотите повторно внедрять Convert.ToByte. Используйте что-то более продвинутое (см. Другие ответы), которое не используется, Convert.ToByteесли вам нужна производительность. Есть не что - нибудь еще другое использование , чем String.Substringв сочетании с Convert.ToByte, если кто - то имеет что - то интересное , чтобы сказать об этом в комментариях этого ответа.

предупреждение: Ответ на этот вопрос может устареть , еслиConvert.ToByte(char[], Int32) перегрузка осуществляется в рамках. Это вряд ли произойдет в ближайшее время.

Как правило, я не очень люблю говорить «не оптимизировать преждевременно», потому что никто не знает, когда «преждевременно». Единственное, что вы должны учитывать при принятии решения об оптимизации или нет, это: «У меня есть время и ресурсы для правильного исследования подходов к оптимизации?». Если вы этого не сделаете, то это слишком рано, подождите , пока ваш проект не будет более зрелым или до тех пор , пока нужна производительность (если есть реальная необходимость, то вы будете делать время). А пока сделайте самое простое, что могло бы сработать.

Оригинальный код:

    public static byte[] HexadecimalStringToByteArray_Original(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        for (var i = 0; i < outputLength; i++)
            output[i] = Convert.ToByte(input.Substring(i * 2, 2), 16);
        return output;
    }

Редакция 4:

    public static byte[] HexadecimalStringToByteArray_Rev4(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        using (var sr = new StringReader(input))
        {
            for (var i = 0; i < outputLength; i++)
                output[i] = Convert.ToByte(new string(new char[2] { (char)sr.Read(), (char)sr.Read() }), 16);
        }
        return output;
    }

Редакция избегает String.Substringи используетStringReader вместо этого. Данная причина:

Изменить: вы можете улучшить производительность для длинных строк с помощью однопроходного парсера, например так:

Ну, глядя на код ссылки дляString.Substring , он уже явно "однопроходный"; а почему не должно быть? Он работает на уровне байтов, а не на суррогатных парах.

Тем не менее, он выделяет новую строку, но тогда вам нужно выделить ее для передачи в Convert.ToByteлюбом случае. Кроме того, решение, представленное в ревизии, выделяет еще один объект на каждой итерации (массив из двух символов); Вы можете безопасно поместить это распределение за пределы цикла и повторно использовать массив, чтобы избежать этого.

    public static byte[] HexadecimalStringToByteArray(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        using (var sr = new StringReader(input))
        {
            for (var i = 0; i < outputLength; i++)
            {
                numeral[0] = (char)sr.Read();
                numeral[1] = (char)sr.Read();
                output[i] = Convert.ToByte(new string(numeral), 16);
            }
        }
        return output;
    }

Каждый шестнадцатеричный numeralпредставляет один октет с использованием двух цифр (символов).

Но тогда зачем звонить StringReader.Readдважды? Просто вызовите его вторую перегрузку и попросите его прочитать сразу два символа в массиве из двух символов; и уменьшить количество звонков на два.

    public static byte[] HexadecimalStringToByteArray(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        using (var sr = new StringReader(input))
        {
            for (var i = 0; i < outputLength; i++)
            {
                var read = sr.Read(numeral, 0, 2);
                Debug.Assert(read == 2);
                output[i] = Convert.ToByte(new string(numeral), 16);
            }
        }
        return output;
    }

То, что у вас осталось, это средство чтения строк, единственным добавленным «значением» которого является параллельный индекс (внутренний _pos), который вы могли бы объявить самостоятельно (как, jнапример), избыточная переменная длины (внутренняя _length) и избыточная ссылка на вход строка (внутренняя_s ). Другими словами, это бесполезно.

Если вам интересно, как Read«читается», просто посмотрите на код , все, что он делает, это вызывает String.CopyToвходную строку. Все остальное - это просто расходы на ведение бухгалтерского учета для поддержания ценностей, которые нам не нужны.

Итак, удалите читатель строки и позвоните CopyToсебе; это проще, понятнее и эффективнее.

    public static byte[] HexadecimalStringToByteArray(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        for (int i = 0, j = 0; i < outputLength; i++, j += 2)
        {
            input.CopyTo(j, numeral, 0, 2);
            output[i] = Convert.ToByte(new string(numeral), 16);
        }
        return output;
    }

Вам действительно нужен jиндекс, который увеличивается с шагом в две параллели i? Конечно, нет, просто умножьте iна два (что компилятор должен уметь оптимизировать до сложения).

    public static byte[] HexadecimalStringToByteArray_BestEffort(string input)
    {
        var outputLength = input.Length / 2;
        var output = new byte[outputLength];
        var numeral = new char[2];
        for (int i = 0; i < outputLength; i++)
        {
            input.CopyTo(i * 2, numeral, 0, 2);
            output[i] = Convert.ToByte(new string(numeral), 16);
        }
        return output;
    }

Как выглядит решение сейчас? Точно так же, как это было в начале, только вместо того, String.Substringчтобы использовать для выделения строки и копирования в нее данных, вы используете промежуточный массив, в который вы копируете шестнадцатеричные цифры, затем выделяете строку самостоятельно и снова копируете данные из массив и в строку (когда вы передаете его в конструкторе строки). Вторая копия может быть оптимизирована, если строка уже находится в пуле интернирования, но в этом String.Substringслучае ее также можно будет избежать.

Фактически, если вы посмотрите String.Substringснова, вы увидите, что он использует некоторые низкоуровневые внутренние знания о том, как строятся строки, чтобы распределить строку быстрее, чем вы обычно это делаете, и он вставляет тот же код, который используется CopyToнепосредственно там, чтобы избежать накладные расходы.

String.Substring

• В худшем случае: одно быстрое размещение, одна быстрая копия.
• В лучшем случае: нет выделения, нет копии.

Ручной метод

• В худшем случае: два обычных размещения, одно обычное копирование, одно быстрое копирование.
• В лучшем случае: одно нормальное распределение, одна нормальная копия.

Вывод? Если вы хотите использоватьConvert.ToByte(String, Int32) (потому что вы не хотите повторно реализовывать эту функциональность самостоятельно), похоже, нет способа победить String.Substring; все, что вы делаете, это бегаете кругами, заново изобретая колесо (только с неоптимальными материалами).

Обратите внимание, что использование Convert.ToByteи String.Substringявляется вполне допустимым выбором, если вам не нужна высокая производительность. Помните: выбирайте альтернативу, только если у вас есть время и ресурсы, чтобы выяснить, как она работает правильно.

Если Convert.ToByte(char[], Int32)бы это было, конечно, все было бы иначе (можно было бы сделать то, что я описал выше, и полностью избежать String).

Я подозреваю, что люди, которые сообщают о лучшей производительности, «избегая String.Substring», также избегают Convert.ToByte(String, Int32), что вы действительно должны делать, если вам все равно нужна производительность. Посмотрите на бесчисленное множество других ответов, чтобы обнаружить все различные подходы для этого.

Отказ от ответственности: я не декомпилировал последнюю версию фреймворка, чтобы убедиться, что справочный источник обновлен, я предполагаю, что это так.

Теперь все это звучит хорошо и логично, надеюсь, даже очевидно, если вам удалось продвинуться так далеко. Но так ли это?

Intel(R) Core(TM) i7-3720QM CPU @ 2.60GHz
    Cores: 8
    Current Clock Speed: 2600
    Max Clock Speed: 2600
--------------------
Parsing hexadecimal string into an array of bytes
--------------------
HexadecimalStringToByteArray_Original: 7,777.09 average ticks (over 10000 runs), 1.2X
HexadecimalStringToByteArray_BestEffort: 8,550.82 average ticks (over 10000 runs), 1.1X
HexadecimalStringToByteArray_Rev4: 9,218.03 average ticks (over 10000 runs), 1.0X

Да!

Реквизит в Partridge для каркаса скамейки, его легко взломать. В качестве входных данных используется следующий хэш SHA-1, повторенный 5000 раз, чтобы получить строку длиной 100 000 байт.

209113288F93A9AB8E474EA78D899AFDBB874355

Радоваться, веселиться! (Но оптимизируйте с модерацией.)

Дополнение к ответу @CodesInChaos (обратный метод)

public static byte[] HexToByteUsingByteManipulation(string s)
{
    byte[] bytes = new byte[s.Length / 2];
    for (int i = 0; i < bytes.Length; i++)
    {
        int hi = s[i*2] - 65;
        hi = hi + 10 + ((hi >> 31) & 7);

        int lo = s[i*2 + 1] - 65;
        lo = lo + 10 + ((lo >> 31) & 7) & 0x0f;

        bytes[i] = (byte) (lo | hi << 4);
    }
    return bytes;
}

Объяснение:

& 0x0f должен поддерживать также строчные буквы

hi = hi + 10 + ((hi >> 31) & 7); такой же как:

hi = ch-65 + 10 + (((ch-65) >> 31) & 7);

Для '0' .. '9' это то же самое, hi = ch - 65 + 10 + 7;что есть hi = ch - 48(это из-за 0xffffffff & 7).

Для 'A' .. 'F' это hi = ch - 65 + 10;(это из-за 0x00000000 & 7).

Для 'a' .. 'f' мы должны получить большие числа, поэтому мы должны вычесть 32 из версии по умолчанию, сделав несколько битов 0, используя & 0x0f.

65 код для 'A'

48 код для '0'

7 - количество букв между '9'и 'A'в таблице ASCII ( ...456789:;<=>?@ABCD...).

Эту проблему также можно решить с помощью справочной таблицы. Это потребует небольшого количества статической памяти как для кодера, так и для декодера. Однако этот метод будет быстрым:

• Таблица кодировщика 512 байт или 1024 байт (в два раза больше, если требуется прописная и строчная буквы)
• Таблица декодера 256 байтов или 64 КиБ (либо поиск одного символа, либо поиск двух символов)

Мое решение использует 1024 байта для таблицы кодирования и 256 байтов для декодирования.

Декодирование

private static readonly byte[] LookupTable = new byte[] {
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};

private static byte Lookup(char c)
{
  var b = LookupTable[c];
  if (b == 255)
    throw new IOException("Expected a hex character, got " + c);
  return b;
}

public static byte ToByte(char[] chars, int offset)
{
  return (byte)(Lookup(chars[offset]) << 4 | Lookup(chars[offset + 1]));
}

кодирование

private static readonly char[][] LookupTableUpper;
private static readonly char[][] LookupTableLower;

static Hex()
{
  LookupTableLower = new char[256][];
  LookupTableUpper = new char[256][];
  for (var i = 0; i < 256; i++)
  {
    LookupTableLower[i] = i.ToString("x2").ToCharArray();
    LookupTableUpper[i] = i.ToString("X2").ToCharArray();
  }
}

public static char[] ToCharLower(byte[] b, int bOffset)
{
  return LookupTableLower[b[bOffset]];
}

public static char[] ToCharUpper(byte[] b, int bOffset)
{
  return LookupTableUpper[b[bOffset]];
}

сравнение

StringBuilderToStringFromBytes:   106148
BitConverterToStringFromBytes:     15783
ArrayConvertAllToStringFromBytes:  54290
ByteManipulationToCharArray:        8444
TableBasedToCharArray:              5651 *

* это решение

Запись

Во время декодирования могут возникнуть IOException и IndexOutOfRangeException (если символ имеет слишком высокое значение> 256). Методы для де / кодирования потоков или массивов должны быть реализованы, это просто подтверждение концепции.

Это отличная статья. Мне нравится решение Валида. Я не прошел тест Патриджа, но, похоже, он проходит довольно быстро. Мне также потребовался обратный процесс, преобразование шестнадцатеричной строки в байтовый массив, поэтому я написал ее как обращение решения Валида. Не уверен, что это быстрее, чем оригинальное решение Томалака. Опять же, я не запускал обратный процесс через тест Патриджа.

private byte[] HexStringToByteArray(string hexString)
{
    int hexStringLength = hexString.Length;
    byte[] b = new byte[hexStringLength / 2];
    for (int i = 0; i < hexStringLength; i += 2)
    {
        int topChar = (hexString[i] > 0x40 ? hexString[i] - 0x37 : hexString[i] - 0x30) << 4;
        int bottomChar = hexString[i + 1] > 0x40 ? hexString[i + 1] - 0x37 : hexString[i + 1] - 0x30;
        b[i / 2] = Convert.ToByte(topChar + bottomChar);
    }
    return b;
}

Зачем делать это сложным? Это просто в Visual Studio 2008:

C #:

string hex = BitConverter.ToString(YourByteArray).Replace("-", "");

VB:

Dim hex As String = BitConverter.ToString(YourByteArray).Replace("-", "")

Чтобы не отвечать на многие ответы здесь, я нашел довольно оптимальную (~ 4,5 раза лучше, чем принято) прямую реализацию синтаксического анализатора шестнадцатеричных строк. Сначала вывод моих тестов (первая партия - моя реализация):

Give me that string:
04c63f7842740c77e545bb0b2ade90b384f119f6ab57b680b7aa575a2f40939f

Time to parse 100,000 times: 50.4192 ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

Accepted answer: (StringToByteArray)
Time to parse 100000 times: 233.1264ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

With Mono's implementation:
Time to parse 100000 times: 777.2544ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

With SoapHexBinary:
Time to parse 100000 times: 845.1456ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F

Строки base64 и BitConverter'd проверяют правильность. Обратите внимание, что они равны.

Реализация:

public static byte[] ToByteArrayFromHex(string hexString)
{
  if (hexString.Length % 2 != 0) throw new ArgumentException("String must have an even length");
  var array = new byte[hexString.Length / 2];
  for (int i = 0; i < hexString.Length; i += 2)
  {
    array[i/2] = ByteFromTwoChars(hexString[i], hexString[i + 1]);
  }
  return array;
}

private static byte ByteFromTwoChars(char p, char p_2)
{
  byte ret;
  if (p <= '9' && p >= '0')
  {
    ret = (byte) ((p - '0') << 4);
  }
  else if (p <= 'f' && p >= 'a')
  {
    ret = (byte) ((p - 'a' + 10) << 4);
  }
  else if (p <= 'F' && p >= 'A')
  {
    ret = (byte) ((p - 'A' + 10) << 4);
  } else throw new ArgumentException("Char is not a hex digit: " + p,"p");

  if (p_2 <= '9' && p_2 >= '0')
  {
    ret |= (byte) ((p_2 - '0'));
  }
  else if (p_2 <= 'f' && p_2 >= 'a')
  {
    ret |= (byte) ((p_2 - 'a' + 10));
  }
  else if (p_2 <= 'F' && p_2 >= 'A')
  {
    ret |= (byte) ((p_2 - 'A' + 10));
  } else throw new ArgumentException("Char is not a hex digit: " + p_2, "p_2");

  return ret;
}

Я попробовал кое-что с unsafeи переместил (явно избыточную) ifпоследовательность символов в клев на другой метод, но это было быстрее всего.

(Я допускаю, что это отвечает на половину вопроса. Я чувствовал, что преобразование string-> byte [] было недопредставлено, в то время как угол строки byte [] ->, кажется, хорошо покрыт. Таким образом, этот ответ.)

Безопасные версии:

public static class HexHelper
{
    [System.Diagnostics.Contracts.Pure]
    public static string ToHex(this byte[] value)
    {
        if (value == null)
            throw new ArgumentNullException("value");

        const string hexAlphabet = @"0123456789ABCDEF";

        var chars = new char[checked(value.Length * 2)];
        unchecked
        {
            for (int i = 0; i < value.Length; i++)
            {
                chars[i * 2] = hexAlphabet[value[i] >> 4];
                chars[i * 2 + 1] = hexAlphabet[value[i] & 0xF];
            }
        }
        return new string(chars);
    }

    [System.Diagnostics.Contracts.Pure]
    public static byte[] FromHex(this string value)
    {
        if (value == null)
            throw new ArgumentNullException("value");
        if (value.Length % 2 != 0)
            throw new ArgumentException("Hexadecimal value length must be even.", "value");

        unchecked
        {
            byte[] result = new byte[value.Length / 2];
            for (int i = 0; i < result.Length; i++)
            {
                // 0(48) - 9(57) -> 0 - 9
                // A(65) - F(70) -> 10 - 15
                int b = value[i * 2]; // High 4 bits.
                int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
                b = value[i * 2 + 1]; // Low 4 bits.
                val += (b - '0') + ((('9' - b) >> 31) & -7);
                result[i] = checked((byte)val);
            }
            return result;
        }
    }
}

Небезопасные версии Для тех, кто предпочитает производительность и не боится небезопасности. На 35% быстрее ToHex и на 10% быстрее FromHex.

public static class HexUnsafeHelper
{
    [System.Diagnostics.Contracts.Pure]
    public static unsafe string ToHex(this byte[] value)
    {
        if (value == null)
            throw new ArgumentNullException("value");

        const string alphabet = @"0123456789ABCDEF";

        string result = new string(' ', checked(value.Length * 2));
        fixed (char* alphabetPtr = alphabet)
        fixed (char* resultPtr = result)
        {
            char* ptr = resultPtr;
            unchecked
            {
                for (int i = 0; i < value.Length; i++)
                {
                    *ptr++ = *(alphabetPtr + (value[i] >> 4));
                    *ptr++ = *(alphabetPtr + (value[i] & 0xF));
                }
            }
        }
        return result;
    }

    [System.Diagnostics.Contracts.Pure]
    public static unsafe byte[] FromHex(this string value)
    {
        if (value == null)
            throw new ArgumentNullException("value");
        if (value.Length % 2 != 0)
            throw new ArgumentException("Hexadecimal value length must be even.", "value");

        unchecked
        {
            byte[] result = new byte[value.Length / 2];
            fixed (char* valuePtr = value)
            {
                char* valPtr = valuePtr;
                for (int i = 0; i < result.Length; i++)
                {
                    // 0(48) - 9(57) -> 0 - 9
                    // A(65) - F(70) -> 10 - 15
                    int b = *valPtr++; // High 4 bits.
                    int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
                    b = *valPtr++; // Low 4 bits.
                    val += (b - '0') + ((('9' - b) >> 31) & -7);
                    result[i] = checked((byte)val);
                }
            }
            return result;
        }
    }
}