1528

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

4

50 に答える 50

1563

Convert.ToHexString.NET 5 以降で使用できます。
逆の操作の方法もあります: Convert.FromHexString.

古いバージョンの .NET では、次のいずれかを使用できます。

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です。詳細については、この回答を参照してください。より良いパフォーマンスが必要な場合は、Convert.ToByteドロップする前に回避する必要がありますSubString。

于 2008-11-22T10:19:28.480 に答える
527

パフォーマンス分析

注：2015年8月20日現在の新しいリーダー。

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

免責事項

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

結果

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

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

テストコード

使用したテストコードを自由に試してみてください。ここにはバージョンが含まれていますが、リポジトリのクローンを作成して、独自のメソッドを追加してください。何か面白いものを見つけた場合、または使用するテストフレームワークの改善を支援したい場合は、プルリクエストを送信してください。

  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.Concat Array.ConvertAllた（.NET 4.0が必要です）。string.Joinバージョンと同等。

更新（2012-02-05）

テストリポジトリには、などのバリアントがさらに含まれていStringBuilder.Append(b.ToString("X2"))ます。結果を混乱させるものはありません。たとえば、foreachより高速ですが、それでも勝ちます。{IEnumerable}.AggregateBitConverter

更新（2012-04-03）

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

更新（2013-01-15）

CodesInChaosのバイト操作の回答を追加しました。これは最初の場所を引き継ぎました（テキストの大きなブロックで大きなマージンがあります）。

更新（2013-05-23）

NathanMoinvaziriのルックアップ回答とBrianLambertのブログからのバリアントを追加しました。どちらもかなり高速ですが、私が使用したテストマシン（AMD Phenom 9750）では主導権を握っていません。

更新（2014-07-31）

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

更新（2015-08-20）

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

于 2009-03-08T21:56:41.770 に答える
255

まさにあなたが望むことをする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();
}
于 2010-03-31T20:42:47.303 に答える
152

暗号化コードを作成するときは、データに依存するタイミングがサイドチャネル攻撃につながる可能性があるため、ランタイムがデータに依存しないように、データに依存するブランチとテーブルルックアップを回避するのが一般的です。

また、かなり高速です。

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の文字になります。AF
  3. i >> 31符号拡張のおかげで、符号付き32ビット整数で使用すると符号が抽出されます。それは-1のためになりi < 0ます。0i >= 0
  4. 2）と3）を組み合わせると、それ(b-10)>>31が0文字と-1数字になります。
  5. 文字の場合を見ると、最後の被加数はになり0、b10から15の範囲にあります。これをA（65）からF（70）にマップします。これは、55（'A'-10）を追加することを意味します。
  6. 数字の場合を見て、最後の被加数をb0から9の範囲から0（48）から9（57）の範囲にマップするように適合させたいと思います。これは、-7（）になる必要があることを意味します'0' - 55。
    これで、7を掛けることができます。ただし、-1はすべてのビットが1であるため、代わりに& -7since(0 & -7) == 0と。を使用できます(-1 & -7) == -7。

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

  • にインデックスを付けるために2番目のループ変数を使用しませんでした。cこれは、測定により、からの計算のi方が安価であることが示されているためです。
  • i < bytes.Lengthループの上限とまったく同じように使用すると、JITterはの境界チェックを排除できるbytes[i]ため、そのバリアントを選択しました。
  • intを作成bすると、バイトからおよびバイトへの不要な変換が可能になります。
于 2013-01-15T08:04:48.533 に答える
111

よりも柔軟性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")));

（後者は元の投稿へのコメントから。）

于 2008-11-22T14:29:19.300 に答える
79

別のルックアップ テーブル ベースのアプローチ。これは、ニブルごとのルックアップ テーブルではなく、バイトごとに 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;
}
于 2014-06-21T16:44:25.230 に答える
68

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[])

于 2008-11-22T14:23:26.957 に答える
57

今日、まったく同じ問題が発生し、次のコードに遭遇しました。

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

出典：Forum post byte [] Array to Hex String（PZahraによる投稿を参照）。コードを少し変更して、0xプレフィックスを削除しました。

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

于 2009-03-11T00:51:09.213 に答える
24

.NET 5 RC2 以降では、以下を使用できます。

スパン パラメーターを受け取るオーバーロードを使用できます。

于 2020-10-22T21:25:39.980 に答える
22

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

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

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

警告:フレームワークにオーバーロードが実装されている場合、この回答は時代遅れになる可能性があります。Convert.ToByte(char[], Int32)これがすぐに起こる可能性は低いです。

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

元のコード:

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

リビジョン 4:

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

リビジョンは a を回避String.Substringし、代わりに使用しStringReaderます。与えられた理由は次のとおりです。

編集: 次のように、シングル パス パーサーを使用して、長い文字列のパフォーマンスを向上させることができます。

の参照コードをString.Substring見ると、すでに「シングルパス」であることは明らかです。なぜそうすべきではないのですか？サロゲート ペアではなく、バイト レベルで動作します。

ただし、新しい文字列を割り当てますが、Convert.ToByteとにかく渡すために1つ割り当てる必要があります。さらに、リビジョンで提供されるソリューションは、反復ごとにさらに別のオブジェクト (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 つの数字 (シンボル) を使用して 1 つのオクテットを表します。

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自分で宣言した並列インデックス ( internal ) (jたとえば)、冗長な長さ変数 ( internal _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 進数をコピーする中間配列を使用してから、自分で文字列を割り当ててからデータを再度コピーします。配列を文字列に変換します (文字列コンストラクターで渡す場合)。文字列が既にインターン プールにある場合、2 番目のコピーは最適化されない可能性がありますがString.Substring、これらの場合も回避できます。

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

String.Substring

  • 最悪の場合: 1 回の高速割り当て、1 回の高速コピー。
  • 最良のケース: 割り当てなし、コピーなし。

手動方法

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

結論？使用したい場合Convert.ToByte(String, Int32)(その機能を自分で再実装したくないため)、打ち負かす方法はないようですString.Substring。あなたがすることは、円を描くように走り、車輪を再発明することだけです (次善の材料のみ)。

極端なパフォーマンスが必要ない場合は、Convert.ToByteandを使用することは完全に有効な選択であることに注意してください。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

楽しむ！(ただし、適度に最適化してください。)

于 2014-10-10T16:39:28.987 に答える
19

@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使用していくつかのビットを作成して、デフォルト バージョンから 32 を減算する必要があります& 0x0f。

65はのコードです'A'

48はのコードです'0'

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

于 2013-07-29T12:23:25.170 に答える
19

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

  • エンコーダ テーブル 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 を超える場合)。ストリームまたは配列をデコード/エンコードするメソッドを実装する必要があります。これは単なる概念実証です。

于 2011-06-08T06:01:42.040 に答える
12

なぜ複雑にするのですか？これは、Visual Studio 2008 では簡単です。

C#:

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

VB:

Dim hex As String = BitConverter.ToString(YourByteArray).Replace("-", "")
于 2010-10-20T00:55:42.277 に答える
10

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

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;
}
于 2010-01-12T16:51:38.193 に答える
8

ここで多くの回答を積み上げるつもりはありませんが、かなり最適な (受け入れられているよりも 4.5 倍優れている) 16 進文字列パーサーの簡単な実装を見つけました。まず、私のテストからの出力 (最初のバッチは私の実装です):

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ましたが、これが最速でした。

(これが質問の半分に答えていることは認めます。文字列->バイト[] 変換が過小評価されていると感じましたが、バイト[]->文字列の角度は十分にカバーされているようです。したがって、この回答.)

于 2012-05-22T16:50:58.560 に答える
7

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

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

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

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

   return hex.ToString();   
}

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

于 2010-09-29T18:41:29.303 に答える
6

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);
    }
于 2015-12-17T11:15:19.587 に答える
5

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

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つのソリューションのいずれかを使用します（最後のソリューションは文字列の拡張メソッドです）。

于 2008-11-22T13:27:49.347 に答える
5

.NET 5 では、Convert.ToHexStringメソッドが追加されました。

古いバージョンの .NET を使用している場合

internal static class ByteArrayExtensions
{
    
    public static string ToHexString(this byte[] bytes, Casing casing = Casing.Upper)
    {
        Span<char> result = stackalloc char[0];
        if (bytes.Length > 16)
        {
            var array = new char[bytes.Length * 2];
            result = array.AsSpan();
        }
        else
        {
            result = stackalloc char[bytes.Length * 2];
        }

        int pos = 0;
        foreach (byte b in bytes)
        {
            ToCharsBuffer(b, result, pos, casing);
            pos += 2;
        }

        return result.ToString();
    }

    private static void ToCharsBuffer(byte value, Span<char> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
    {
        uint difference = (((uint)value & 0xF0U) << 4) + ((uint)value & 0x0FU) - 0x8989U;
        uint packedResult = ((((uint)(-(int)difference) & 0x7070U) >> 4) + difference + 0xB9B9U) | (uint)casing;

        buffer[startingIndex + 1] = (char)(packedResult & 0xFF);
        buffer[startingIndex] = (char)(packedResult >> 8);
    }
}

public enum Casing : uint
{
    // Output [ '0' .. '9' ] and [ 'A' .. 'F' ].
    Upper = 0,

    // Output [ '0' .. '9' ] and [ 'a' .. 'f' ].
    Lower = 0x2020U,
}

.NET リポジトリから適応 https://github.com/dotnet/runtime/blob/v5.0.3/src/libraries/System.Private.CoreLib/src/System/Convert.cs https://github.com/dotnet /runtime/blob/v5.0.3/src/libraries/Common/src/System/HexConverter.cs

于 2021-03-02T09:58:08.157 に答える
3

Oliproさん、あなたが提案したコードが機能しませんでした。hex[i] + hex[i+1]どうやらを返しましたint。

しかし、私はWaleedsコードからいくつかのヒントを取り、これを一緒にハンマーで叩くことによって、ある程度の成功を収めました。それは地獄のように醜いですが、私のテスト（パトリッジテストメカニズムを使用）によると、他のものと比較して1/3の時間で動作し、実行されているようです。入力サイズによって異なります。最初に0〜9を区切るために？：sを切り替えると、文字よりも数字の方が多いため、結果がわずかに速くなる可能性があります。

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;
}
于 2010-05-22T22:20:18.190 に答える
3

速度に関しては、これはここにある何よりも優れているようです。

  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);
  }
于 2010-06-01T08:19:33.490 に答える
3

このバージョンの 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);
    }
于 2013-08-23T07:07:38.153 に答える
3

また、SQL 文字列に挿入する場合 (コマンド パラメーターを使用していない場合):

public static String ByteArrayToSQLHexString(byte[] Source)
{
    return = "0x" + BitConverter.ToString(Source).Replace("-", "");
}
于 2009-09-14T21:13:35.893 に答える
3

パフォーマンスのために、drphrozensソリューションを使用します。デコーダーの小さな最適化は、どちらかの文字のテーブルを使用して「<< 4」を取り除くことです。

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

offset++andoffsetの代わりにoffsetandを使用すると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]));
}

これは私の思いつきであり、テストもベンチマークもされていません。

于 2011-06-08T07:09:15.000 に答える
2

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

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;          
}
于 2011-06-16T20:33:53.093 に答える
2

これが私のショットです。文字列とバイトを拡張する拡張クラスのペアを作成しました。大きなファイルのテストでは、パフォーマンスは Byte Manipulation 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

上記の結果に基づいて、次のように結論付けても安全だと思われます。

  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 の回答からのものです。

インテル 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

于 2013-06-03T23:24:36.470 に答える
2

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

退廃的な 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;
}
于 2013-05-15T13:09:00.830 に答える
2

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

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);
}
于 2016-05-20T16:23:25.693 に答える
2

速度は最適化されていませんが、ほとんどの回答よりも 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
于 2013-08-30T23:53:04.533 に答える
2

16 進文字列をバイト配列に変換する、まだ言及されていない単純なワンライナー ソリューションがあります (ここでは問題にならないため、否定的な解釈は気にしません)。

BigInteger.Parse(str, System.Globalization.NumberStyles.HexNumber).ToByteArray().Reverse().ToArray();
于 2020-03-10T21:23:22.687 に答える
1

その速度は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);
    }
于 2012-12-16T20:40:59.690 に答える
1

これは、文字列からバイト配列に移動するために機能します...

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();
    }
于 2012-05-25T17:38:38.010 に答える
1

もあります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());
    }
于 2013-10-24T09:53:28.783 に答える
1

パフォーマンスが重要な場合は、最適化されたソリューションを次に示します。

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

よりも約 2.5 倍高速であり、「-」文字を削除したBitConverter.ToString場合よりも約 7 倍高速です。BitConverter.ToString

于 2011-04-10T00:56:25.790 に答える
1

以下は、ネイティブの小文字オプションも許可することにより、ここでの優れた回答を拡張し、 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);
    }
于 2015-10-20T22:51:39.553 に答える
1

余分な文字 (空白、ダッシュ...) を許容する別のコードを思いつきました。ほとんどの場合、ここで許容できるほど高速な回答からインスピレーションを得ています。次の「ファイル」の解析を可能にします

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
}

コピーするときは、完全なコードを参照してください。単体テストが含まれています。

余分な文字に対して寛容すぎると言う人もいるかもしれません。したがって、このコードに依存して検証を実行 (または変更) しないでください。

于 2019-05-30T12:55:50.510 に答える
0

wcoenen によって報告された「4 倍の速度増加」を取得したい場合、それが明白でない場合: に置き換えhex.Substring(i, 2)ますhex[i]+hex[i+1]

さらに一歩進んで、両方の場所でi+=2使用することで を取り除くこともできます。i++

于 2010-01-02T22:28:07.087 に答える