バイト配列から16進数文字列への変換、およびその逆の変換方法は？

Question

バイト配列から16進数文字列への変換、およびその逆の変換方法は？

Answer 1

どちらか

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("-","");
}

here のように、それを実行する方法はもっとあります。

逆変換は次のようになります。

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と組み合わせた最良のオプションです。詳しくは この答え をご覧ください。より良いパフォーマンスが必要な場合は、SubStringをドロップする前にConvert.ToByteを避けなければなりません。

Answer 2

パフォーマンス分析

注：2015-08-20の時点での新しいリーダー。

私はいくつかの粗いStopwatchパフォーマンステスト、ランダムな文による実行（n = 61、1000の反復）、およびProject Gutenburgテキストによる実行（n = 1,238,957、150の反復）を通じて、さまざまな変換方法をそれぞれ実行しました。これは、おおよそ最速から最短までの結果です。すべての測定はティック（ 10,000ティック= 1 ms ）で行われ、すべての相対ノートは[最も遅い] StringBuilderの実装と比較されます。使用されているコードについては、下記または テストフレームワークレポ を参照してください。ここで、これを実行するためのコードを管理しています。

免責事項

警告：具体的なことにこれらの統計を当てにしないでください。これらは単にサンプルデータのサンプル実行です。あなたが本当に最高のパフォーマンスを必要とするならば、あなたが使用するものの代表的なデータであなたの生産のニーズを代表する環境でこれらの方法をテストしてください。

結果

• Code_InChaosを介してバイトunsafeによるルックアップ （ airbreather でテストレポジトリに追加されました）
  • テキスト：4,727.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.9倍速い）
• バイト操作（Waleed Eissa経由）
  • テキスト：16,856.64（29.5倍速い）
  • 文：0.70（39.5倍速い）
• ルックアップ/シフト（Nathan Moinvaziri経由）
  • テキスト：23,201.23（21.4倍速）
  • センテンス：1.24（22.3倍速）
• ニブルによる検索（Brian Lambert経由）
  • テキスト：23,879.41（20.8倍速い）
  • センテンス：1.15（23.9倍速）
• BitConverter（Tomalak経由）
  • テキスト：113,269.34（4.4倍速）
  • センテンス：9.98（2.8倍速）
• {SoapHexBinary}.ToString（Mykroft経由）
  • テキスト：178,601.39（2.8倍速）
  • センテンス：10.68（2.6倍速）
• {byte}.ToString("X2")（foreachを使用）（Will Deanの回答から派生）
  • テキスト：308,805.38（2.4倍速）
  • センテンス：16.89（2.4倍速）
• {byte}.ToString("X2")（{IEnumerable}.Aggregateを使うにはSystem.Linqが必要です）（Mark経由）
  • テキスト：352,828.20（2.1倍速）
  • センテンス：16.87（2.4倍速）
• Array.ConvertAll（string.Joinを使う）（Will Deanによる）
  • テキスト：675,451.57（1.1倍速）
  • センテンス：17.95（2.2倍速）
• Array.ConvertAll（string.Concatを使うには.NET 4.0が必要です）（Will Deanによる）
  • テキスト：752,078.70（1.0倍速）
  • センテンス：18.28（2.2倍速）
• {StringBuilder}.AppendFormat（foreachを使って）（Tomalak経由）
  • テキスト：672,115.77（1.1倍速）
  • 文：36.82（1.1倍速）
• {StringBuilder}.AppendFormat（{IEnumerable}.Aggregateを使うにはSystem.Linqが必要です）（Tomalakの回答から派生）
  • テキスト：718,380.63（1.0倍速）
  • センテンス：39.71（1.0倍速）

ルックアップテーブルはバイト操作よりも優れています。基本的には、与えられたニブルまたはバイトが16進数になるものを事前計算する何らかの形式があります。それから、データをリッピングしながら、次の部分を調べて、それがどのような16進数ストリングであるかを確認します。その値は、何らかの方法で結果の文字列出力に追加されます。長い間、一部の開発者にとっては読みにくくなる可能性があるバイト操作が、最高のパフォーマンスを発揮するアプローチでした。

あなたの最善の策は、まだいくつかの代表的なデータを見つけて、本番のような環境でそれを試すことです。メモリの制約が異なる場合は、割り当てが少ないほうが高速ではあるがより多くのメモリを消費する方法をお勧めします。

テストコード

私が使ったテストコードを試してみてください。ここにはバージョンが含まれていますが、 repo を複製して独自のメソッドを追加しても構いません。もし何かおもしろいことがあれば、あるいはそれが使用するテストフレームワークの改善を手助けしたい場合は、プルリクエストを送ってください。

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）

分析にWaleedの答えを追加しました。かなり速いです。

更新日（2011-10-05）

完全を期すためにstring.ConcatArray.ConvertAllバリアントを追加しました（.NET 4.0が必要です）。 string.Joinバージョンと同等です。

更新（2012-02-05）

テストレポジトリには、StringBuilder.Append(b.ToString("X2"))などの他のバリアントが含まれています。どれも結果を混乱させません。例えばforeachは{IEnumerable}.Aggregateより速いです、しかし、BitConverterはまだ勝ちます。

更新（2012-04-03）

Mykroftの分析に対するSoapHexBinaryの回答を追加しました。

更新（2013-01-15）

CodesInChaosのバイト操作の回答を追加しました。これは、（テキストの大きなブロックに対して大きなマージンで）最初の場所を引き継いだものです。

更新（2013-05-23）

Nathan Moinvaziriの検索回答とBrian Lambertのブログの変種を追加しました。どちらもかなり速いですが、私が使用したテスト機（AMD Phenom 9750）をリードしていません。

更新日（2014-07-31）

@ CodesInChaosの新しいバイトベースの検索回答を追加しました。文章テストと全文テストの両方で主導的な役割を果たしたようです。

更新日（2015-08-20）

これに airbreather's 最適化とunsafeバリアントを追加しました answer's repo 。安全でないゲームでプレイしたい場合は、短い文字列と大きなテキストの両方で、これまでのトップ勝者のいずれよりも大幅にパフォーマンスが向上する可能性があります。

Answer 3

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

Answer 4

暗号コードを書くとき、ランタイムがデータに依存しないことを確実にするためにデータ依存の分岐とテーブル検索を避けることは一般的です。

それはまたかなり速いです。

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です。これは、10進数になります。
   は、値>= 0に対するb > 10です。これは、AからFへの文字になります。
3. 符号付き32ビット整数にi >> 31を使用すると、符号拡張のおかげで符号が抽出されます。 -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. 数字の場合を見て、最後の被加数を0から9の範囲のbを0（48）から9（57）の範囲にマッピングします。これは、-7（'0' - 55）になる必要があることを意味します。
   しかし、-1はすべてのビットが1で表されるので、代わりに& -7と(0 & -7) == 0から(-1 & -7) == -7を使用できます。

いくつかのさらなる考慮事項：

• cからそれを計算することはより安いことを測定が示しているので、私はiにインデックスを付けるのに2番目のループ変数を使いませんでした。
• ループの上限として正確にi < bytes.Lengthを使用することで、JITterはbytes[i]の境界チェックを排除することができるので、私はその変形を選択しました。
• bをintにすると、バイトからバイトへの不要な変換が可能になります。

Answer 5

もしあなたが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")));

（後者は元の記事へのコメントから）

Answer 6

あなたは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 []）

Answer 7

別のルックアップテーブルベースのアプローチこれは、ニブルごとのルックアップテーブルではなく、各バイトに対して1つのルックアップテーブルのみを使用します。

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

Answer 8

私は今日、非常に同じ問題に遭遇しました、そして私はこのコードに出くわしました：

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 [] 16進文字列への配列（PZahraによる投稿を参照）。 0xプレフィックスを削除するようにコードを少し修正しました。

私はいくつかのパフォーマンステストをコードに対して行いました、そしてそれはBitConverter.ToString（）を使うよりもほぼ8倍高速でした（patridgeの投稿によると最も速い）。

Answer 9

これは、 Tomalakの非常に人気のある回答 （およびその後の編集）の リビジョン4 に対する回答です。

この編集が間違っていると主張し、元に戻すことができる理由を説明します。途中で、いくつかの内部構造について1つか2つを学び、時期尚早な最適化が実際に何であり、それがどのように噛みつくことができるかについてのさらに別の例を見るかもしれません。

tl; dr：急いでいる場合はConvert.ToByteとString.Substringを使用します（以下の「オリジナルコード」）。そうしない場合は最適な組み合わせですConvert.ToByteを再実装したい。 必要パフォーマンスの場合、Convert.ToByteを使用しない、より高度なもの（他の回答を参照）を使用します。この答えのコメントで誰かがこれについて興味深いことを言っているのでない限り、String.Substring以外の何かをConvert.ToByteと組み合わせてnot使用してください。

warning：この答えは時代遅れになるかもしれませんifConvert.ToByte(char[], Int32)オーバーロードがフレームワークに実装されています。これはすぐには起こりそうにありません。

一般的なルールとして、「時期尚早」がいつなのか誰にもわからないため、「時期尚早に最適化しない」と言うのは好きではありません。最適化するかどうかを決定するときに考慮する必要があるのは、「最適化アプローチを適切に調査する時間とリソースがありますか？」だけです。そうでなければ、プロジェクトがより成熟するまで、またはパフォーマンスが必要になるまで待ちます（実際に必要な場合は、make時間）。それまでの間、代わりに動作する可能性のある最も単純なことを行います。

元のコード：

    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に渡すには割り当てる必要があります。さらに、リビジョンで提供されるソリューションは、反復ごとにさらに別のオブジェクト（2文字の配列）を割り当てます。その割り当てをループの外に安全に配置し、それを回避するために配列を再利用できます。

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

各16進数numeralは、2桁（シンボル）を使用して単一のオクテットを表します。

しかし、なぜStringReader.Readを2回呼び出すのですか？ 2番目のオーバーロードを呼び出して、2文字の配列の2つの文字を一度に読み取るように要求します。呼び出しの量を2つ減らします。

    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に2並列のステップで増分するiインデックスが本当に必要ですか？もちろん、iに2を掛けるだけです（コンパイラーは、追加に最適化できるはずです）。

    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を使用して文字列を割り当ててデータをコピーする代わりに、16進数のコピー先の中間配列を使用してから、文字列を自分で割り当ててデータをコピーします- again配列から文字列へ（文字列コンストラクターで渡すとき）。文字列が既にインターンプールにある場合、2番目のコピーは最適化されている可能性がありますが、これらの場合はString.Substringもそれを回避できます。

実際、String.Substringをもう一度見ると、文字列がどのように構築されているかについての低レベルの内部知識を使用して、通常よりも速く文字列を割り当てることがわかり、CopyToによって直接使用される同じコードがインライン化される呼び出しのオーバーヘッドを回避します。

String.Substring

• 最悪の場合：1つの高速割り当て、1つの高速コピー。
• ベストケース：割り当てなし、コピーなし。

手作業による方法

• 最悪の場合：2つの通常の割り当て、1つの通常のコピー、1つの高速コピー。
• ベストケース：通常の割り当てが1つ、通常のコピーが1つ。

結論？ 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の小道具、簡単にハックします。使用される入力は、100,000バイトの文字列を作成するために5000回繰り返される次のSHA-1ハッシュです。

209113288F93A9AB8E474EA78D899AFDBB874355

楽しむ！ （ただし、適度に最適化します。）

Answer 10

この問題はルックアップテーブルを使用しても解決できます。これは、エンコーダとデコーダの両方に少量の静的メモリを必要とします。しかしこの方法は速いでしょう：

• エンコーダテーブル512バイトまたは1024バイト（大文字と小文字の両方が必要な場合はサイズの2倍）
• デコーダテーブル256バイトまたは64 KiB（単一文字検索または二重文字検索）

私のソリューションは、エンコードテーブルに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）。ストリームまたは配列のデコーディング/エンコードのメソッドを実装する必要がありますが、これは概念の証明にすぎません。

Answer 11

@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; } は小文字もサポートするためのものです

hi = hi + 10 + ((hi >> 31) & 7);は以下と同じです。

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

'0' .. '9'の場合、& 0x0fはhi = ch - 65 + 10 + 7;と同じです（これはhi = ch - 48のためです）。

'A' .. 'F'の場合、0xffffffff & 7です（これはhi = ch - 65 + 10;のためです）。

'a' .. 'f'には大きな数値が必要なので、0x00000000 & 7を使用して0を& 0x0fにすることで、デフォルトバージョンから32を減算する必要があります。

65は'A'のコードです

48は'0'のコードです

7は、ASCIIテーブルの'9'と'A'の間の文字数です（...456789:;<=>?@ABCD...）。

Answer 12

これは素晴らしい投稿です。私はWaleedの解決策が好きです。私はpatridgeのテストを通してそれを実行していませんが、それはかなり速いようです。また、16進数の文字列をバイト配列に変換する逆の処理も必要でしたので、それをWaleedの解決策の逆転として書きました。それがTomalakの最初の解決策より速いかどうかわからない。繰り返しますが、私はpatridgeのテストを通して逆のプロセスも実行しませんでした。

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

Answer 13

なぜそれを複雑にしますか？これはVisual Studio 2008では単純です。

C＃：

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

VB：

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

Answer 14

ここにはたくさんの答えが書かれていませんが、16進文字列パーサーのかなり最適な（受け入れられているものより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を使って（明らかに冗長な）character-to-nibbleのifシーケンスを別の方法に移すことを試みましたが、これが最速でした。

（私はこれが質問の半分に答えると認めています。文字列 - > byte []の変換は過少表現されているように感じましたが、byte [] - >文字列の角度はうまくカバーされているようです。

Answer 15

安全なバージョン：

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

危険なバージョン パフォーマンスを好むが危険ではないと思う人のためのものです。 ToHexが約35％、FromHexが10％速くなりました。

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

_ btw _ convert関数の呼び出しが間違っているたびにアルファベットを初期化するベンチマークテストでは、alphabetはconst（文字列の場合）またはstatic readonly（char []の場合）にする必要があります。次に、byte []からstringへのアルファベットベースの変換は、バイト操作バージョンと同じくらい速くなります。

そしてもちろんtestはRelease（最適化あり）でデバッグオプション "Suppress JIT最適化"をオフにしてコンパイルしなければなりません（コードがデバッグ可能でなければならない場合は "Enable Just My Code"と同じです）。

Answer 16

Waleed Eissaコードの逆関数（16進文字列からバイト配列へ）：

    public static byte[] HexToBytes(this string hexString)        
    {
        byte[] b = new byte[hexString.Length / 2];            
        char c;
        for (int i = 0; i < hexString.Length / 2; i++)
        {
            c = hexString[i * 2];
            b[i] = (byte)((c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57)) << 4);
            c = hexString[i * 2 + 1];
            b[i] += (byte)(c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57));
        }

        return b;
    }

小文字サポート付きのWaleed Eissa機能

    public static string BytesToHex(this byte[] barray, bool toLowerCase = true)
    {
        byte addByte = 0x37;
        if (toLowerCase) addByte = 0x57;
        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 + addByte : b + 0x30);
            b = ((byte)(barray[i] & 0xF));
            c[i * 2 + 1] = (char)(b > 9 ? b + addByte : b + 0x30);
        }

        return new string(c);
    }

Answer 17

拡張メソッド （免責事項：完全にテストされていないコード、ところで…）：

public static class ByteExtensions
{
    public static string ToHexString(this byte[] ba)
    {
        StringBuilder hex = new StringBuilder(ba.Length * 2);

        foreach (byte b in ba)
        {
            hex.AppendFormat("{0:x2}", b);
        }
        return hex.ToString();
    }
}

等.. Tomalakの3つの解決策 のいずれかを使用してください - /（最後のものは文字列の拡張メソッドです）。

Answer 18

Microsoftの開発者からの、素敵で単純な変換：

public static string ByteArrayToString(byte[] ba) 
{
    // Concatenate the bytes into one long string
    return ba.Aggregate(new StringBuilder(32),
                            (sb, b) => sb.Append(b.ToString("X2"))
                            ).ToString();
}

上記はきれいですがコンパクトですが、パフォーマンスの中毒者は列挙子を使ってそれについて叫びます。あなたはトモラックのオリジナルの答えの改良版で最高のパフォーマンスを得ることができます：

public static string ByteArrayToString(byte[] ba)   
{   
   StringBuilder hex = new StringBuilder(ba.Length * 2);   

   for(int i=0; i < ga.Length; i++)       // <-- Use for loop is faster than foreach   
       hex.Append(ba[i].ToString("X2"));   // <-- ToString is faster than AppendFormat   

   return hex.ToString();   
} 

これは私がこれまでにここに投稿したのを見た中で最も速いルーチンです。私のWordをそれだけにしないでください...各ルーチンをパフォーマンステストし、自分のCILコードを調べます。

Answer 19

スピードの面では、これはここの何よりも優れているようです。

  public static string ToHexString(byte[] data) {
    byte b;
    int i, j, k;
    int l = data.Length;
    char[] r = new char[l * 2];
    for (i = 0, j = 0; i < l; ++i) {
      b = data[i];
      k = b >> 4;
      r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
      k = b & 15;
      r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
    }
    return new string(r);
  }

Answer 20

decode / hexadecimalsにもちょっと手間をかけた答えもあるので、このちょっとした手間のかかる競争に入ります。 StringBuilderメソッドの呼び出しにも時間がかかるため、文字配列の使用はさらに高速になる可能性があります。

public static String ToHex (byte[] data)
{
    int dataLength = data.Length;
    // pre-create the stringbuilder using the length of the data * 2, precisely enough
    StringBuilder sb = new StringBuilder (dataLength * 2);
    for (int i = 0; i < dataLength; i++) {
        int b = data [i];

        // check using calculation over bits to see if first Tuple is a letter
        // isLetter is zero if it is a digit, 1 if it is a letter
        int isLetter = (b >> 7) & ((b >> 6) | (b >> 5)) & 1;

        // calculate the code using a multiplication to make up the difference between
        // a digit character and an alphanumerical character
        int code = '0' + ((b >> 4) & 0xF) + isLetter * ('A' - '9' - 1);
        // now append the result, after casting the code point to a character
        sb.Append ((Char)code);

        // do the same with the lower (less significant) Tuple
        isLetter = (b >> 3) & ((b >> 2) | (b >> 1)) & 1;
        code = '0' + (b & 0xF) + isLetter * ('A' - '9' - 1);
        sb.Append ((Char)code);
    }
    return sb.ToString ();
}

public static byte[] FromHex (String hex)
{

    // pre-create the array
    int resultLength = hex.Length / 2;
    byte[] result = new byte[resultLength];
    // set validity = 0 (0 = valid, anything else is not valid)
    int validity = 0;
    int c, isLetter, value, validDigitStruct, validDigit, validLetterStruct, validLetter;
    for (int i = 0, hexOffset = 0; i < resultLength; i++, hexOffset += 2) {
        c = hex [hexOffset];

        // check using calculation over bits to see if first char is a letter
        // isLetter is zero if it is a digit, 1 if it is a letter (upper & lowercase)
        isLetter = (c >> 6) & 1;

        // calculate the Tuple value using a multiplication to make up the difference between
        // a digit character and an alphanumerical character
        // minus 1 for the fact that the letters are not zero based
        value = ((c & 0xF) + isLetter * (-1 + 10)) << 4;

        // check validity of all the other bits
        validity |= c >> 7; // changed to >>, maybe not OK, use UInt?

        validDigitStruct = (c & 0x30) ^ 0x30;
        validDigit = ((c & 0x8) >> 3) * (c & 0x6);
        validity |= (isLetter ^ 1) * (validDigitStruct | validDigit);

        validLetterStruct = c & 0x18;
        validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2);
        validity |= isLetter * (validLetterStruct | validLetter);

        // do the same with the lower (less significant) Tuple
        c = hex [hexOffset + 1];
        isLetter = (c >> 6) & 1;
        value ^= (c & 0xF) + isLetter * (-1 + 10);
        result [i] = (byte)value;

        // check validity of all the other bits
        validity |= c >> 7; // changed to >>, maybe not OK, use UInt?

        validDigitStruct = (c & 0x30) ^ 0x30;
        validDigit = ((c & 0x8) >> 3) * (c & 0x6);
        validity |= (isLetter ^ 1) * (validDigitStruct | validDigit);

        validLetterStruct = c & 0x18;
        validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2);
        validity |= isLetter * (validLetterStruct | validLetter);
    }

    if (validity != 0) {
        throw new ArgumentException ("Hexadecimal encoding incorrect for input " + hex);
    }

    return result;
}

Javaコードから変換されました。

Answer 21

このバージョンのByteArrayToHexViaByteManipulationはもっと速いかもしれません。

私の報告から：

• ByteArrayToHexViaByteManipulation3：1,68平均ティック（1000以上の実行）、17,5X
• ByteArrayToHexViaByteManipulation2：平均平均ティック数1,73（1000ランを超える）、16,9X
• ByteArrayToHexViaByteManipulation：2,90平均ティック（1000ランを超える）、10,1X
• ByteArrayToHexViaLookupAndShift：3,22平均ティック（1000回以上のラン）、9,1X

• ...

  static private readonly char[] hexAlphabet = new char[]
      {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  static string ByteArrayToHexViaByteManipulation3(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] = hexAlphabet[b];
          b = ((byte)(bytes[i] & 0xF));
          c[i * 2 + 1] = hexAlphabet[b];
      }
      return new string(c);
  }
  

そしてこれは最適化だと思います。

    static private readonly char[] hexAlphabet = new char[]
        {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    static string ByteArrayToHexViaByteManipulation4(byte[] bytes)
    {
        char[] c = new char[bytes.Length * 2];
        for (int i = 0, ptr = 0; i < bytes.Length; i++, ptr += 2)
        {
            byte b = bytes[i];
            c[ptr] = hexAlphabet[b >> 4];
            c[ptr + 1] = hexAlphabet[b & 0xF];
        }
        return new string(c);
    }

Answer 22

あなたが提案したコードがうまく動かない、Olipro。 hex[i] + hex[i+1]はどうやらintを返しました。

しかし、私はWaleedsのコードからいくつかのヒントを得て、これを一緒に打っていくことで成功しました。それは地獄のように醜いですが、それは私のテストによると（パトリッジテストメカニズムを使用して）他の人に比べて動作し、時間の3分の1で実行されるようです。入力サイズによって異なります。 ？：sを切り替えて最初に0-9を切り離すと、文字よりも数字が多くなるため、おそらく若干速い結果が得られます。

public static byte[] StringToByteArray2(string hex)
{
    byte[] bytes = new byte[hex.Length/2];
    int bl = bytes.Length;
    for (int i = 0; i < bl; ++i)
    {
        bytes[i] = (byte)((hex[2 * i] > 'F' ? hex[2 * i] - 0x57 : hex[2 * i] > '9' ? hex[2 * i] - 0x37 : hex[2 * i] - 0x30) << 4);
        bytes[i] |= (byte)(hex[2 * i + 1] > 'F' ? hex[2 * i + 1] - 0x57 : hex[2 * i + 1] > '9' ? hex[2 * i + 1] - 0x37 : hex[2 * i + 1] - 0x30);
    }
    return bytes;
}

Answer 23

パフォーマンスのために私はdrphrozensソリューションを使います。デコーダのための小さな最適化は "<< 4"を取り除くためにどちらかのcharのためにテーブルを使うことかもしれません。

2つのメソッド呼び出しは明らかにコストがかかります。入力データまたは出力データ（CRC、チェックサム、その他）で何らかのチェックが行われると、if (b == 255)...をスキップすることができ、それによってメソッドも完全に呼び出されます。

offsetおよびoffset++の代わりにoffset + 1およびoffsetを使用すると、理論上の利点が得られる場合がありますが、私はコンパイラがこれをうまく処理していると思います。

private static readonly byte[] LookupTableLow = 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
};

private static readonly byte[] LookupTableHigh = 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, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 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, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 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 LookupLow(char c)
{
  var b = LookupTableLow[c];
  if (b == 255)
    throw new IOException("Expected a hex character, got " + c);
  return b;
}

private static byte LookupHigh(char c)
{
  var b = LookupTableHigh[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)(LookupHigh(chars[offset++]) | LookupLow(chars[offset]));
}

これは私の頭のすぐ上にあり、テストもベンチマークもされていません。

Answer 24

多様性のためのさらに別のバリエーション：

public static byte[] FromHexString(string src)
{
    if (String.IsNullOrEmpty(src))
        return null;

    int index = src.Length;
    int sz = index / 2;
    if (sz <= 0)
        return null;

    byte[] rc = new byte[sz];

    while (--sz >= 0)
    {
        char lo = src[--index];
        char hi = src[--index];

        rc[sz] = (byte)(
            (
                (hi >= '0' && hi <= '9') ? hi - '0' :
                (hi >= 'a' && hi <= 'f') ? hi - 'a' + 10 :
                (hi >= 'A' && hi <= 'F') ? hi - 'A' + 10 :
                0
            )
            << 4 | 
            (
                (lo >= '0' && lo <= '9') ? lo - '0' :
                (lo >= 'a' && lo <= 'f') ? lo - 'a' + 10 :
                (lo >= 'A' && lo <= 'F') ? lo - 'A' + 10 :
                0
            )
        );
    }

    return rc;          
}

Answer 25

もう一つの速い機能...

private static readonly byte[] HexNibble = new byte[] {
    0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
    0x8, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
    0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
};

public static byte[] HexStringToByteArray( string str )
{
    int byteCount = str.Length >> 1;
    byte[] result = new byte[byteCount + (str.Length & 1)];
    for( int i = 0; i < byteCount; i++ )
        result[i] = (byte) (HexNibble[str[i << 1] - 48] << 4 | HexNibble[str[(i << 1) + 1] - 48]);
    if( (str.Length & 1) != 0 )
        result[byteCount] = (byte) HexNibble[str[str.Length - 1] - 48];
    return result;
}

Answer 26

もう1つの方法は、GCメモリの負荷を減らすためにstackallocを使用することです。

static string ByteToHexBitFiddle(byte[] bytes)
{
        var c = stackalloc char[bytes.Length * 2 + 1];
        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));
        }
        c[bytes.Length * 2 ] = '\0';
        return new string(c);
}

Answer 27

SQL文字列に挿入する場合（コマンドパラメータを使用していない場合）：

public static String ByteArrayToSQLHexString(byte[] Source)
{
    return = "0x" + BitConverter.ToString(Source).Replace("-", "");
}

Answer 28

2つのマッシュアップ。2つのニブル操作を1つにまとめます。

おそらくかなり効率的なバージョン：

public static string ByteArrayToString2(byte[] ba)
{
    char[] c = new char[ba.Length * 2];
    for( int i = 0; i < ba.Length * 2; ++i)
    {
        byte b = (byte)((ba[i>>1] >> 4*((i&1)^1)) & 0xF);
        c[i] = (char)(55 + b + (((b-10)>>31)&-7));
    }
    return new string( c );
}

退屈なlinq-with-bit-hackingバージョン：

public static string ByteArrayToString(byte[] ba)
{
    return string.Concat( ba.SelectMany( b => new int[] { b >> 4, b & 0xF }).Select( b => (char)(55 + b + (((b-10)>>31)&-7))) );
}

そしてその逆：

public static byte[] HexStringToByteArray( string s )
{
    byte[] ab = new byte[s.Length>>1];
    for( int i = 0; i < s.Length; i++ )
    {
        int b = s[i];
        b = (b - '0') + ((('9' - b)>>31)&-7);
        ab[i>>1] |= (byte)(b << 4*((i&1)^1));
    }
    return ab;
}

Answer 29

スピードには最適化されていませんが、ほとんどの答えよりLINQyが優れています（.NET 4.0）。

<Extension()>
Public Function FromHexToByteArray(hex As String) As Byte()
    hex = If(hex, String.Empty)
    If hex.Length Mod 2 = 1 Then hex = "0" & hex
    Return Enumerable.Range(0, hex.Length \ 2).Select(Function(i) Convert.ToByte(hex.Substring(i * 2, 2), 16)).ToArray
End Function

<Extension()>
Public Function ToHexString(bytes As IEnumerable(Of Byte)) As String
    Return String.Concat(bytes.Select(Function(b) b.ToString("X2")))
End Function

Answer 30

これが私のショットです。私は文字列とバイトを拡張するための一対の拡張クラスを作成しました。ラージファイルテストでは、パフォーマンスはバイト操作2と同等です。

以下のToHexStringのコードは、ルックアップおよびシフトアルゴリズムの最適化された実装です。これはBehroozによるものとほぼ同じですが、繰り返し処理にforeachを使用しているため、明示的にインデックスを付けるforよりもカウンターのほうが高速です。

それは私のマシンのByte Manipulation 2の後ろの2位にあり、とても読みやすいコードです。次のテスト結果も重要です。

ToHexStringCharArrayWithCharArrayLookup：平均チック数（1000回以上）、1.5X ToHexStringCharArrayWithStringLookup：50,764.06回の平均チック数（1000回以上）、1.2X ToHexStringStringBuilderWithCharArrayLookup：62,812.87平均ティック×1.0

上記の結果に基づいて、次のように結論付けても安全です。

1. 検索を実行するための文字列へのインデックス付けとchar配列の比較のペナルティは、ラージファイルテストでは重要です。
2. 既知の容量のStringBuilderと既知のサイズのchar配列を使用して文字列を作成した場合のペナルティはさらに大きくなります。

これがコードです：

using System;

namespace ConversionExtensions
{
    public static class ByteArrayExtensions
    {
        private readonly static char[] digits = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

        public static string ToHexString(this byte[] bytes)
        {
            char[] hex = new char[bytes.Length * 2];
            int index = 0;

            foreach (byte b in bytes)
            {
                hex[index++] = digits[b >> 4];
                hex[index++] = digits[b & 0x0F];
            }

            return new string(hex);
        }
    }
}


using System;
using System.IO;

namespace ConversionExtensions
{
    public static class StringExtensions
    {
        public static byte[] ToBytes(this string hexString)
        {
            if (!string.IsNullOrEmpty(hexString) && hexString.Length % 2 != 0)
            {
                throw new FormatException("Hexadecimal string must not be empty and must contain an even number of digits to be valid.");
            }

            hexString = hexString.ToUpperInvariant();
            byte[] data = new byte[hexString.Length / 2];

            for (int index = 0; index < hexString.Length; index += 2)
            {
                int highDigitValue = hexString[index] <= '9' ? hexString[index] - '0' : hexString[index] - 'A' + 10;
                int lowDigitValue = hexString[index + 1] <= '9' ? hexString[index + 1] - '0' : hexString[index + 1] - 'A' + 10;

                if (highDigitValue < 0 || lowDigitValue < 0 || highDigitValue > 15 || lowDigitValue > 15)
                {
                    throw new FormatException("An invalid digit was encountered. Valid hexadecimal digits are 0-9 and A-F.");
                }
                else
                {
                    byte value = (byte)((highDigitValue << 4) | (lowDigitValue & 0x0F));
                    data[index / 2] = value;
                }
            }

            return data;
        }
    }
}

以下は、私のコードを@ patridgeのテストプロジェクトに追加したときに得られたテスト結果です。また、16進数からバイト配列に変換するためのテストも追加しました。私のコードを実行したテスト実行はByteArrayToHexViaOptimizedLookupAndShiftとHexToByteArrayViaByteManipulationです。 HexToByteArrayViaConvertToByteはXXXXから取得されました。 HexToByteArrayViaSoapHexBinaryは@ Mykroftの回答からのものです。

Intel Pentium III Xeonプロセッサ

    Cores: 4 <br/>
    Current Clock Speed: 1576 <br/>
    Max Clock Speed: 3092 <br/>

---

バイト配列を16進文字列表現に変換する

---

ByteArrayToHexViaByteManipulation2：39,366.64平均ティック（1000回を超えるラン）、22.4X

ByteArrayToHexViaOptimizedLookupAndShift：41,588.64平均ティック（1000回を超えるラン）、21.2X

ByteArrayToHexViaLookup：55,509.56平均ティック（1000ランを超える）、15.9X

ByteArrayToHexViaByteManipulation：65,349.12平均ティック（1000回を超えるラン）、13.5X

ByteArrayToHexViaLookupAndShift：86,926.87平均ティック（1000回を超えるラン）、10.2X

ByteArrayToHexStringViaBitConverter：139,353.73平均ティック（1000回を超えるラン）、6.3X

ByteArrayToHexViaSoapHexBinary：314,598.77平均ティック（1000回を超えるラン）、2.8X

ByteArrayToHexStringViaStringBuilderForEachByteToString：344,264.63平均ティック（1000以上の実行）、2.6X

ByteArrayToHexStringViaStringBuilderAggregateByteToString：382,623.44平均ティック（1000回を超えるラン）、2.3X

ByteArrayToHexStringViaStringBuilderForEachAppendFormat：818,111.95平均ティック（1000回を超えるラン）、1.1X

ByteArrayToHexStringViaStringConcatArrayConvertAll：839,244.84平均ティック（1000以上の実行）、1.1X

ByteArrayToHexStringViaStringBuilderAggregateAppendFormat：867,303.98平均ティック（1000回を超えるラン）、1.0X

ByteArrayToHexStringViaStringJoinArrayConvertAll：882,710.28平均ティック（1000以上の実行）、1.0X

---

Answer 31

パフォーマンスが重要な場合は、これが最適化されたソリューションです。

    static readonly char[] _hexDigits = "0123456789abcdef".ToCharArray();
    public static string ToHexString(this byte[] bytes)
    {
        char[] digits = new char[bytes.Length * 2];
        for (int i = 0; i < bytes.Length; i++)
        {
            int d1, d2;
            d1 = Math.DivRem(bytes[i], 16, out d2);
            digits[2 * i] = _hexDigits[d1];
            digits[2 * i + 1] = _hexDigits[d2];
        }
        return new string(digits);
    }

BitConverter.ToStringの約2.5倍、BitConverter.ToStringの7倍の速さで ' - 'の文字を削除しています。

Answer 32

これは文字列からバイト配列へと進むように働きます...

public static byte[] StrToByteArray(string str)
    {
        Dictionary<string, byte> hexindex = new Dictionary<string, byte>();
        for (byte i = 0; i < 255; i++)
            hexindex.Add(i.ToString("X2"), i);

        List<byte> hexres = new List<byte>();
        for (int i = 0; i < str.Length; i += 2)
            hexres.Add(hexindex[str.Substring(i, 2)]);

        return hexres.ToArray();
    }

Answer 33

私はその速度が16余分なバイトの価値があると思います。

    static char[] hexes = new char[]{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    public static string ToHexadecimal (this byte[] Bytes)
    {
        char[] Result = new char[Bytes.Length << 1];
        int Offset = 0;
        for (int i = 0; i != Bytes.Length; i++) {
            Result[Offset++] = hexes[Bytes[i] >> 4];
            Result[Offset++] = hexes[Bytes[i] & 0x0F];
        }
        return new string(Result);
    }

Answer 34

XmlWriter.WriteBinHexもあります（MSDN ページ を参照）。これは、16進数ストリングをXMLストリームに入れる必要がある場合に非常に役立ちます。

これがどのように機能するのかを確認するためのスタンドアロンの方法は次のとおりです。

    public static string ToBinHex(byte[] bytes)
    {
        XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
        xmlWriterSettings.ConformanceLevel = ConformanceLevel.Fragment;
        xmlWriterSettings.CheckCharacters = false;
        xmlWriterSettings.Encoding = ASCIIEncoding.ASCII;
        MemoryStream memoryStream = new MemoryStream();
        using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
        {
            xmlWriter.WriteBinHex(bytes, 0, bytes.Length);
        }
        return Encoding.ASCII.GetString(memoryStream.ToArray());
    }

Answer 35

static string ByteArrayToHexViaLookupPerByte2(byte[] bytes)
{                
        var result3 = new uint[bytes.Length];
        for (int i = 0; i < bytes.Length; i++)
                result3[i] = _Lookup32[bytes[i]];
        var handle = GCHandle.Alloc(result3, GCHandleType.Pinned);
        try
        {
                var result = Marshal.PtrToStringUni(handle.AddrOfPinnedObject(), bytes.Length * 2);
                return result;
        }
        finally
        {
                handle.Free();
        }
}

私のテストでは、この関数は常に安全でない実装の2番目のエントリです。

残念ながら、テストベンチの信頼性はそれほど高くありません。複数回実行すると、リストがあまりにもシャッフルされてしまい、安全ではないことがわかります。予熱、ジットコンパイル時間、およびGCパフォーマンスへの影響は考慮されていません。より多くの情報を得るために書き直したかったのですが、実際には時間がありませんでした。

Answer 36

私は余分な文字（空白文字、ダッシュ...）を許容する別の コードを思いつきました 。それは主にここでいくつかの容認できるほど速い答えから促されます。それは以下の「ファイル」の解析を可能にします

00-aa-84-fb
12 32 FF CD
12 00
12_32_FF_CD
1200d5e68a

/// <summary>Reads a hex string into bytes</summary>
public static IEnumerable<byte> HexadecimalStringToBytes(string hex) {
    if (hex == null)
        throw new ArgumentNullException(nameof(hex));

    char c, c1 = default(char);
    bool hasc1 = false;
    unchecked   {
        for (int i = 0; i < hex.Length; i++) {
            c = hex[i];
            bool isValid = 'A' <= c && c <= 'f' || 'a' <= c && c <= 'f' || '0' <= c && c <= '9';
            if (!hasc1) {
                if (isValid) {
                    hasc1 = true;
                }
            } else {
                hasc1 = false;
                if (isValid) {
                    yield return (byte)((GetHexVal(c1) << 4) + GetHexVal(c));
                }
            }

            c1 = c;
        } 
    }
}

/// <summary>Reads a hex string into a byte array</summary>
public static byte[] HexadecimalStringToByteArray(string hex)
{
    if (hex == null)
        throw new ArgumentNullException(nameof(hex));

    var bytes = new List<byte>(hex.Length / 2);
    foreach (var item in HexadecimalStringToBytes(hex)) {
        bytes.Add(item);
    }

    return bytes.ToArray();
}

private static byte GetHexVal(char val)
{
    return (byte)(val - (val < 0x3A ? 0x30 : val < 0x5B ? 0x37 : 0x57));
    //                   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^   ^^^^
    //                       digits 0-9       upper char A-Z     a-z
}

コピーする場合は フルコード を参照してください。単体テストが含まれています。

それは余分な文字に対してあまりにも寛容すぎると言うかもしれません。そのため、検証を実行する（または変更する）ためにこのコードに頼らないでください。

Answer 37

以下は、ネイティブの小文字オプションを許可することで、優れた答え here を拡張し、nullまたは空の入力も処理し、これを拡張メソッドにします。

    /// <summary>
    /// Converts the byte array to a hex string very fast. Excellent job
    /// with code lightly adapted from 'community wiki' here: https://stackoverflow.com/a/14333437/264031
    /// (the function was originally named: ByteToHexBitFiddle). Now allows a native lowerCase option
    /// to be input and allows null or empty inputs (null returns null, empty returns empty).
    /// </summary>
    public static string ToHexString(this byte[] bytes, bool lowerCase = false)
    {
        if (bytes == null)
            return null;
        else if (bytes.Length == 0)
            return "";

        char[] c = new char[bytes.Length * 2];

        int b;
        int xAddToAlpha = lowerCase ? 87 : 55;
        int xAddToDigit = lowerCase ? -39 : -7;

        for (int i = 0; i < bytes.Length; i++) {

            b = bytes[i] >> 4;
            c[i * 2] = (char)(xAddToAlpha + b + (((b - 10) >> 31) & xAddToDigit));

            b = bytes[i] & 0xF;
            c[i * 2 + 1] = (char)(xAddToAlpha + b + (((b - 10) >> 31) & xAddToDigit));
        }

        string val = new string(c);
        return val;
    }

    public static string ToHexString(this IEnumerable<byte> bytes, bool lowerCase = false)
    {
        if (bytes == null)
            return null;
        byte[] arr = bytes.ToArray();
        return arr.ToHexString(lowerCase);
    }