バイト配列を16進文字列に、またはその逆にどのように変換しますか？

https://stackoverflow.com/questions/311165

10-07-2019
|

質問

バイト配列を16進文字列に、またはその逆に変換するにはどうすればよいですか？

解決

いずれか：

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

他のヒント

パフォーマンス分析

注：2015-08-20現在の新しいリーダー。

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

免責事項

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

結果

バイトによるルックアップunsafe（CodesInChaos経由）（テストリポジトリに airbreather ）
- テキスト：4,727.85（105.2X）
- 文：0.28（99.7X）
バイトによるルックアップ（CodesInChaos経由）
- テキスト：10,853.96（45.8X高速）
- 文：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倍高速）
ニブルによるルックアップ（ブライアンランバート経由）
- テキスト：23,879.41（20.8X高速）
- 文：1.15（23.9倍高速）
BitConverter（トマラック経由）
- テキスト：113,269.34（4.4X高速）
- 文章：9.98（2.8倍高速）
{SoapHexBinary}.ToString（Mykroft経由）
- テキスト：178,601.39（2.8倍高速）
- 文：10.68（2.6倍高速）
{byte}.ToString("X2")（foreachを使用）（ウィルディーンの回答から派生）
- テキスト：308,805.38（2.4倍高速）
- 文：16.89（2.4倍高速）
{IEnumerable}.Aggregate（Array.ConvertAllを使用、System.Linqが必要）（Mark経由）
- テキスト：352,828.20（2.1X高速）
- 文：16.87（2.4倍高速）
string.Join（string.Concatを使用）（Will Dean経由）
- テキスト：675,451.57（1.1X高速）
- 文：17.95（2.2倍高速）
{StringBuilder}.AppendFormat（Func<byte[], string>を使用、.NET 4.0が必要）（Will Dean経由）
- テキスト：752,078.70（1.0X高速）
- 文：18.28（2.2倍高速）
TestCandidates（GenerateTestInputを使用）（Tomalak経由）
- テキスト：672,115.77（1.1X高速）
- 文：36.82（1.1倍高速）
StringBuilder.Append(b.ToString("X2"))（SoapHexBinaryを使用、System.Linqが必要）（Tomalakのnswer）
- テキスト：718,380.63（1.0倍高速）
- 文：39.71（1.0倍高速）

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

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

テストコード

使用したテストコードを自由に試してみてください。ここにバージョンが含まれていますが、 repo を自由に複製して、独自のメソッドを追加してください。おもしろいものを見つけたり、使用するテストフレームワークの改善に協力したい場合は、プルリクエストを送信してください。

新しい静的メソッド（<=>）を/Tests/ConvertByteArrayToHexString/Test.csに追加します。
メソッドの名前を同じクラスの<=>戻り値に追加します。
同じクラスの<=>のコメントを切り替えることで、目的の入力バージョン（文またはテキスト）を実行していることを確認します。
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）

完全性のために<=> <=>バリアントを追加（.NET 4.0が必要）。 <=>バージョンと同等。

更新（2012-02-05）

テストリポジトリには、<=>などのバリアントが含まれています。結果を混乱させるものはありません。たとえば、<=>は<=>より高速ですが、<=>が勝ちます。

更新（2012-04-03）

分析にMykroftの<=>回答を追加し、3位になりました。

更新（2013-01-15）

CodesInChaosのバイト操作の回答を追加し、1位を引き継いだ（テキストの大きなブロックに大きなマージンを置いて）。

更新（2013-05-23）

Nathan Moinvaziriの検索応答とBrian Lambertのブログのバリアントを追加しました。どちらもかなり高速ですが、使用したテストマシン（AMD Phenom 9750）ではリードしていません。

更新（2014-07-31）

@CodesInChaosの新しいバイトベースのルックアップ応答を追加しました。文テストと全文テストの両方で主導権を握っているようです。

更新（2015-08-20）

この airbreatherの最適化と<=>バリアントを追加しました。 / patridge / PerformanceStubs "rel =" noreferrer ">回答のリポジトリ。安全でないゲームでプレイしたい場合は、短い文字列と大きなテキストの両方で、以前のトップ勝者のいずれよりも大きなパフォーマンスの向上を得ることができます。

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}

すべての希望を捨てる、ここに入る者よ

奇妙な少しいじるの説明：

bytes[i] >> 4バイトの上位ニブルを抽出します
bytes[i] & 0xFバイトの下位ニブルを抽出します
b - 10
< 0の値はb < 10で、10進数になります
>= 0の値はb > 10で、AからFの文字になります。
符号付き32ビット整数でi >> 31を使用すると、符号拡張のおかげで符号が抽出されます。 -1はi < 0、0はi >= 0です。
2）と3）を組み合わせると、(b-10)>>31が文字の場合b、数字の場合'A'-10になることが示されています。
文字の大文字小文字を見ると、最後の加数は9になり、'0' - 55は10から15の範囲にあります。これを& -7（65）から(0 & -7) == 0（70）にマッピングします。 55（(-1 & -7) == -7）を追加することを意味します。
数字の場合を見て、最後の被加数を調整して、cを0から9の範囲からi（48）からi < bytes.Length（57）の範囲にマッピングします。つまり、-7（bytes[i]）になる必要があります。
7で乗算できます。ただし、-1はすべてのビットが1で表されるため、代わりに<=>および<=>から<=>を使用できます。

その他の考慮事項：

2番目のループ変数を使用して<=>のインデックスを作成しなかったのは、<=>から計算する方が安価であることが測定結果からわかったからです。
ループの上限として正確に<=>を使用すると、JITterは<=>の境界チェックを排除できるため、そのバリアントを選択しました。
<=>をintにすることで、バイトとの間の不要な変換が可能になります。

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")));

（元の投稿に対するコメントからの後者。）

別のルックアップテーブルベースのアプローチ。これは、ニブルごとのルックアップテーブルではなく、各バイトに対して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;
}

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 []配列から16進文字列 （PZahraの投稿を参照）。コードを少し変更して、0xプレフィックスを削除しました。

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

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

エンコーダテーブル512 <！> nbsp; bytesまたは1024 <！> nbsp; bytes（twice 大文字と小文字の両方の場合のサイズが必要です）
デコーダテーブル256 <！> nbsp; bytesまたは 64 <！> nbsp; KiB（単一文字のルックアップまたはデュアル文字検索）

私のソリューションでは、エンコードテーブルに1024 <！> nbsp; bytesを使用し、デコードに256 <！> nbsp; bytesを使用します。

デコード

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が発生する可能性がありました（文字の値が高すぎる場合<！> gt; 256）。ストリームまたは配列をデコード/エンコードするためのメソッドを実装する必要があります。これは概念実証にすぎません。

これは、リビジョン4 に対する回答です。 311179 ">トマラックの非常に人気のある回答（およびその後の編集）。

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

tl; dr：急いでいる場合（<！> quot; Original code <！> quot;以下）、Convert.ToByteとString.Substringを使用します。これは最適な組み合わせですConvert.ToByte(char[], Int32)を再実装したくない場合。パフォーマンスが必要な場合はStringReaderを使用しない、より高度なもの（他の回答を参照）を使用してください。この回答のコメントで誰かがこれについて興味深いことを言っていない限り、numeralと組み合わせてStringReader.Read以外のものを使用しないでください。

警告：フレームワークに_posオーバーロードが実装されている場合、この答えは時代遅れになる可能性があります。これはすぐには起こりそうにありません。

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

元のコード：

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

リビジョンはjを回避し、代わりに_lengthを使用します。指定された理由は次のとおりです。

編集：長い文字列のパフォーマンスを向上させるには、単一の次のようにパーサーを渡します：

さて、 _s 、それは明らかに<！> quot; single-pass <！> quot;既に;そして、なぜそうではないのですか？サロゲートペアではなく、バイトレベルで動作します。

ただし、新しい文字列は割り当てられますが、とにかくReadに渡すには文字列を割り当てる必要があります。さらに、リビジョンで提供されるソリューションは、反復ごとにさらに別のオブジェクト（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進String.CopyToは、2桁（シンボル）を使用して単一のオクテットを表します。

しかし、なぜCopyToを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;
    }

残っているのは、<！> quot; value <！> quot;のみが追加された文字列リーダーです。自分で宣言できる並列インデックス（内部i）（たとえばConvert.ToByte(String, Int32)）、冗長長変数（内部String）、および入力文字列への冗長参照（内部<=>）。言い換えれば、それは役に立たない。

<=> <！> quot; reads <！> quot;について疑問がある場合は、コードは、入力文字列で<=>を呼び出すだけです。残りは、必要のない値を維持するための帳簿上のオーバーヘッドです。

したがって、文字列リーダーを既に削除し、自分で<=>を呼び出します。よりシンプルで、より明確で、より効率的です。

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

本当に<=>に2並列のステップで増分する<=>インデックスが必要ですか？もちろん、<=>に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;
    }

現在のソリューションはどのようなものですか？文字列aを割り当てるために<=>を使用する代わりに、ちょうど最初にあったようにndにデータをコピーします。16進数のコピー先の中間配列を使用します。次に、文字列を自分で割り当て、配列から文字列にデータを再びコピーします（文字列コンストラクタに渡します）。文字列が既にインターンプールにある場合、2番目のコピーは最適化されている可能性がありますが、これらの場合は<=>も回避できます。

実際、もう一度<=>を見ると、文字列の構築方法に関する低レベルの内部知識を使用して、通常よりも高速に文字列を割り当て、同じコードをインライン展開していることがわかります呼び出しのオーバーヘッドを回避するために、直接<=>で。

<=>

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

手動による方法

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

結論？ <=> を使用する場合（その機能を自分で再実装したくないため）、<=>に勝つ方法はないようです。あなたがすることは、輪になって、車輪を再発明することです（最適でない材料のみ）。

極端なパフォーマンスを必要としない場合、<=>と<=>を使用することは完全に有効な選択であることに注意してください。覚えておいてください。適切に機能する方法を調査する時間とリソースがある場合のみ、代替手段を選択してください。

<=>があった場合、物事はもちろん異なります（上記で説明したことを実行し、<=>を完全に回避することも可能です）。

<！> quot; <=> <！> quot;を回避することでパフォーマンスの向上を報告している人はいると思います。また、パフォーマンスを必要とする場合は、実際に実行する必要がある<=>も避けてください。他の無数の答えを見て、それを行うためのさまざまなアプローチをすべて見つけてください。

免責事項：参照ソースが最新であることを確認するために、フレームワークの最新バージョンを逆コンパイルしていません。

今、それはすべて良いと論理的に聞こえます。しかし、本当ですか？

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

お楽しみください！（ただし、適度に最適化します。）

@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'の場合、大きな数字にする必要があるため、0を使用してビットを'A'にして、デフォルトバージョンから32を減算する必要があります。

65は'0'

のコードです

48は'9'

のコードです

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

これは素晴らしい投稿です。 Waleedのソリューションが好きです。パトリッジのテストを実行していませんが、非常に高速なようです。 16進文字列をバイト配列に変換する逆プロセスも必要だったので、Waleedのソリューションの反転としてそれを書きました。トマラックの元のソリューションよりも速いかどうかはわかりません。繰り返しますが、パトリッジのテストでも逆のプロセスは実行しませんでした。

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 <！> nbsp; Studio <！> nbsp; 2008では簡単です：

C＃：

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

VB：

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

ここで多くの答えを積み重ねることはしませんが、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を使って（明らかに冗長な）文字からニブルへのifシーケンスを別の方法に移動しましたが、これが最速でした。

（これは質問の半分に答えていると思います。string-<！> gt; byte []変換は過少表現されていると感じましたが、byte []-<！> gt; string角度は十分にカバーされているようです。したがって、この答え。）

安全なバージョン：

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

ところで 変換関数が呼び出されるたびにアルファベットを初期化するベンチマークテストでは、アルファベットはconst（文字列の場合）または静的読み取り専用（char []の場合）でなければなりません。次に、byte []から文字列へのアルファベットベースの変換は、バイト操作バージョンと同じくらい速くなります。

そしてもちろん、テストはリリースでコンパイルされ（最適化あり）、デバッグオプション<！> quot; JIT最適化の抑制<！> quot;オフになります（<！> quot; Enable Just My Code <！> quot;コードをデバッグ可能にする必要がある場合）。

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

小文字サポート付きウェールド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);
    }

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

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

など。トマラックの3つのソリューション（最後の1つは文字列の拡張メソッドです）。

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

上記はクリーンですが、コンパクトなパフォーマンス中毒者は列挙子を使用してそれについて叫びます。 Tomolakの元の回答の改良版を使用すると、最高のパフォーマンスを得ることができます。

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

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

速度の点では、これはここの何よりも優れているようです：

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

私は、あなたが提案したコード、Oliproを手に入れませんでした。 hex[i] + hex[i+1]は明らかにintを返しました。

しかし、Waleedsのコードからいくつかのヒントを得て、これを組み合わせることである程度の成功を収めました。それは地獄のようにugいですが、それは動作しているようで、私のテスト（パトリッジテストメカニズムを使用して）によると、他の1/3の時間と比較して実行されます。入力サイズに応じて。？：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;
}

このバージョンのByteArrayToHexViaByteManipulationはより高速になる可能性があります。

レポートから：

ByteArrayToHexViaByteManipulation3：1,68の平均ティック（1000回を超える実行）、17.5 X
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);
    }

ビットフィッドリングを使用して16進数を decode する回答もあるので、このビットフィドルコンペティションに参加します。 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コードから変換。

パフォーマンスについては、drphrozensソリューションを使用します。デコーダーの小さな最適化は、<！> quot; <！> lt; <！> lt;を取り除くためにいずれかのcharのテーブルを使用することです。 4 <！> quot;。

明らかに、2つのメソッド呼び出しにはコストがかかります。入力データまたは出力データ（CRC、チェックサムなど）で何らかの種類のチェックが行われた場合、if (b == 255)...がスキップされる可能性があるため、メソッドも完全に呼び出します。

offset++およびoffsetの代わりにoffset + 1および<=>を使用すると、理論上の利点が得られる可能性がありますが、コンパイラはこれを私よりもうまく処理できると思います。

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

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

また、SQL文字列への挿入用（コマンドパラメーターを使用していない場合）：

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

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

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

速度は最適化されていませんが、ほとんどの回答よりも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

2つのニブル操作を1つに折り畳む2つのマッシュアップ。

おそらく非常に効率的なバージョン：

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

ビットハッキングを伴う10進linqバージョン：

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

別の方法は、stackallocを使用してGCメモリの負荷を減らすことです。

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

これが私のショットです。文字列とバイトを拡張する拡張クラスのペアを作成しました。大容量ファイルのテストでは、パフォーマンスはバイト操作2に匹敵します。

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

これは、私のマシンのByte Manipulation 2に次ぐ2位で、非常に読みやすいコードです。次のテスト結果も興味深いものです：

ToHexStringCharArrayWithCharArrayLookup：41,589.69平均ティック（1000回を超える実行）、1.5X ToHexStringCharArrayWithStringLookup：50,764.06平均ティック（1000回を超える実行）、1.2X ToHexStringStringBuilderWithCharArrayLookup：62,812.87平均ティック（1000回を超える実行）、1.0X

上記の結果に基づいて、次のように結論付けるのは安全なようです：

検索を実行するための文字列へのインデックス付けに対するペナルティvs. 大きいファイルのテストでは、char配列が重要です。
既知の容量の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

別の高速機能...

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

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow