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


1372

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


8
以下の受け入れられた答えは、文字列からバイトへの変換で恐ろしい量の文字列を割り当てるように見えます。これがパフォーマンスにどのように影響するのか疑問に思います
Wim Coenen

9
SoapHexBinaryクラスは、私が思っているとおりのことを行います。
Mykroft 2010年

1つの投稿で2つの質問をするのはあまり標準的ではないようです。
SandRock、

回答:


1353

どちらか:

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

または:

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

これを行うには、さらに多くのバリエーションがあります。たとえば、こちら

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

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

Substringと組み合わせて使用するのが最良のオプションConvert.ToByteです。詳細については、この回答を参照してください。より良いパフォーマンスが必要なConvert.ToByte場合は、ドロップする前に回避する必要がありますSubString


24
SubStringを使用しています。このループは恐ろしい量の文字列オブジェクトを割り当てませんか?
Wim Coenen

30
正直なところ、パフォーマンスが劇的に低下するまでは、これを無視して、ランタイムとGCが信頼できるようにする傾向があります。
トマラック2009年

87
1バイトは2ニブルであるため、バイト配列を有効に表す16進文字列は、文字数が偶数でなければなりません。0はどこにも追加しないでください。1を追加することは、潜在的に危険な無効なデータについて想定することになります。16進文字列に奇数の文字が含まれている場合、StringToByteArrayメソッドはFormatExceptionをスローする必要があります。
David Boike、2009年

7
@ 00jt F == 0Fと仮定する必要があります。0Fと同じか、入力がクリップされ、Fは実際には受信していない何かの始まりです。これらの仮定を行うのはあなたのコンテキスト次第ですが、私は、汎用関数は、呼び出しコードに対してその仮定を行うのではなく、奇数文字を無効として拒否すべきであると私は信じています。
David Boike 2013年

11
@DavidBoike質問は、「クリップされた可能性のあるストリーム値を処理する方法」とは何の関係もありませんでした。文字列myValue = 10.ToString( "X"); myValueは「0A」ではなく「A」です。今度はその文字列をバイトに読み戻して、おっとそれを壊した。
00jt 2013年

488

パフォーマンス分析

注:2015-08-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}.Aggregateが、それBitConverterでも勝ちます。

アップデート(2012-04-03)

SoapHexBinary分析への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の最適化とunsafeバリアントを追加しました。安全でないゲームでプレイしたい場合は、短い文字列と大きなテキストの両方で、以前のトップ勝者よりも大幅にパフォーマンスを向上させることができます。


Waleedの回答のコードをテストしてみませんか?とても速いようです。stackoverflow.com/questions/311165/...
クリスティアン・ダイアコネスキュー

5
リクエストしたとおりのことを自分で実行できるようにコードを用意しましたが、テストコードを更新してWaleedの回答を含めました。すべての不機嫌さはさておき、それははるかに速いです。
パトリッジ

2
@CodesInChaos完了。そして、それは私のテストでもかなり勝ちました。どちらのトップメソッドも完全に理解しているふりはしていませんが、直接的なやり取りから簡単に隠すことができます。
パトリッジ2013年

6
この答えは、「自然」または当たり前の問題に答えるつもりはありません。これらの変換を行う必要がある場合、多くの場合、それらを行う傾向があるので、目標は人々にいくつかの基本的なパフォーマンスベンチマークを与えることです。誰かが未処理の速度を必要とする場合は、目的のコンピューティング環境で適切なテストデータを使用してベンチマークを実行するだけです。次に、そのメソッドを拡張メソッドに組み込み、その実装を二度と見ないようにします(例:)bytes.ToHexStringAtLudicrousSpeed()
パトリッジ2013

2
高性能ルックアップテーブルベースの実装を作成しました。その安全なバリアントは、私のCPU上の現在のリーダーよりも約30%高速です。安全でない亜種はさらに高速です。stackoverflow.com/a/24343727/445517
CodesInChaos

244

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

35
SoapHexBinaryは.NET 1.0から利用可能で、mscorlibにあります。面白い名前空間ですが、質問のとおりです。
スライグリフォン

4
素晴らしい発見!他のソリューションと同様に、GetStringToBytesの奇数の文字列の先頭に0を埋め込む必要があることに注意してください。
カーターメドリン2011年

実装の考え方を見ましたか?受け入れられた答えは、より良い私見です。
mfloryan 2012年

6
:ここでのモノの実装を見るのは興味深いgithub.com/mono/mono/blob/master/mcs/class/corlib/...
ジェレミー・

1
SoapHexBinaryは.NET Core / .NET Standardではサポートされていません...
juFo

141

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

また、かなり高速です。

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

Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn


ここに入るあなたがたは、すべての希望を捨てる

奇妙なビットのいじりの説明:

  1. bytes[i] >> 4バイトの高いニブルを
    bytes[i] & 0xF抽出するバイトの低いニブルを抽出する
  2. b - 10
    ある< 0値のためのb < 10小数の桁になるだろう、
    ある>= 0値のためb > 10からの手紙になるだろう、AF
  3. i >> 31符号付き32ビット整数で使用すると、符号拡張により符号が抽出されます。それは次のようになります-1のためにi < 00のためにi >= 0
  4. 2)と3)を組み合わせると、それ(b-10)>>310文字と-1数字になることがわかります。
  5. 文字の大文字と小文字を見ると、最後の加数はになり0、10〜15 bの範囲になります。これをA(65)〜F(70)にマッピングすると、55('A'-10)が追加されます。
  6. 数字の場合を見て、b0から9の範囲から0(48)から9(57)の範囲にマップするように最後の加数を適応させたいと思います。つまり、-7('0' - 55)になる必要があります。
    これで、7を掛けることができます。ただし、-1はすべてのビットが1で表される& -7ため(0 & -7) == 0、代わりにsince およびを使用でき(-1 & -7) == -7ます。

その他の考慮事項:

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

10
hex stringbyte[] array
AaA 2013年

15
+1の黒魔術を呼び出した後でソースを適切に引用するため。すべてがクトゥルフを呼ぶ。
Edward

4
string to byte []はどうですか?
Syaiful Nizam Yahya 2013

9
いいね!小文字の出力が必要な場合、式は明らかに次のように変更されます87 + b + (((b-10)>>31)&-39)
eXavier

2
@AaAあなたは「言ったbyte[] array、文字通りのバイト配列の配列を意味し、」、またはbyte[][]。ただ面白がっているだけでした。
CoolOppo

97

より柔軟にしたいが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")));

(後者は元の投稿へのコメントから。)


21
さらに短い:String.Concat(Array.ConvertAll(bytes、x => x.ToString( "X2"))
Nestor

14
さらに短い:String.Concat(bytes.Select(b => b.ToString( "X2")))[.
NET4

14
質問の半分しか答えません。
Sly Gryphon

1
なぜ2番目のものには.Net 4が必要なのですか?String.Concatは.Net 2.0にあります。
Polyfun 2014年

2
これらの「90年代スタイル」のループは一般に高速ですが、ほとんどのコンテキストでは問題にならないほどの無視できるほどの量です。まだ言及する価値があります
Austin_Anderson '24年

69

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

私も使用して、このの変異体をテストしたushortstruct{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;
}

安全でないバージョンでルックアップテーブルを作成すると、事前計算されたバイトのニブルが交換されるのはなぜですか?エンディアンは、複数バイトで構成されるエンティティの順序を変更するだけだと思いました。
Raif Atef 2014年

@RaifAtefここで重要なのは、ニブルの順序ではありません。ただし、32ビット整数の16ビットワードの順序。しかし、エンディアンに関係なく同じコードが実行できるように、コードを書き直すことを検討しています。
CodesInChaos 2014年

コードをもう一度読んだと思いますが、後でchar *をuint *にキャストして(16進文字を生成するときに)割り当てると、ランタイム/ CPUがバイトをフリップするためです(uintは処理されないため) 2つの個別の16ビット文字と同じ)なので、補正するためにそれらをプリフリップします。私は正しいですか?エンディアンは混乱します:-)。
Raif Atef 2014年

4
これは質問の半分に答えるだけです... 16進文字列からバイトまではどうですか?
Narvalex

3
@CodesInChaos Span代わりに今使えるのかしらunsafe
Konrad、


56

今日、まったく同じ問題に遭遇し、このコードに出くわしました。

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倍高速でした(パトリッジの投稿によると最速)。


これは最小のメモリを使用することは言うまでもありません。中間ストリングはまったく作成されませんでした。
Chochos、2009年

8
質問の半分しか答えません。
Sly Gryphon

これは、基本的にはNETMFを含むすべてのバージョンのNETで動作するため、すばらしいです。勝者!
Jonesome Reinstate Monica、2012

1
受け入れられた回答は、質問の残りの半分を表す2つの優れたHexToByteArrayメソッドを提供します。Waleedのソリューションは、プロセスで膨大な数の文字列を作成せずにこれを行う方法についての実行中の質問に答えます。
Brendten Eickstaedt 2012年

新しいstring(c)はコピーして再割り当てしますか、それともchar []を単純にラップできるかを知るのに十分スマートですか?
jjxtra 2013年

19

これが答えです改訂4Tomalakの非常に人気のある答え(およびそれ以降の編集)。

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

TL; DR:だけの使用Convert.ToByteString.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;
    }

リビジョンは回避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.Read2回電話するのでしょうか。2番目のオーバーロードを呼び出して、2文字配列の2文字を一度に読み取るように要求するだけです。呼び出しの量を2つ減らします。

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

あなたが残しているのは、追加された「値」だけ_posが自分で宣言できる並列インデックス(内部)j、冗長な長さ変数(内部_length)、および入力への冗長な参照である文字列リーダーです。文字列(内部_s)。言い換えれば、それは役に立たないです。

どのようにRead「読み取る」のか疑問に思う場合は、コードを見てください。コードが行うのはString.CopyTo、入力文字列を呼び出すことだけです。残りは、私たちが必要としない値を維持するための単なる簿記のオーバーヘッドです。

そのため、すでにストリングリーダーを削除し、CopyTo自分自身を呼び出してください。よりシンプルで、明確で、効率的です。

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

本当にj2ずつ平行して増分するインデックスが必要iですか?もちろん、i2を掛けるだけではありません(コンパイラーはこれを加算に最適化できるはずです)。

    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

はい!

ベンチフレームワークのパートリッジへの小道具、それはハッキングするのは簡単です。使用される入力は、100,000バイトの文字列を作成するために5000回繰り返される次のSHA-1ハッシュです。

209113288F93A9AB8E474EA78D899AFDBB874355

楽しんで!(しかし、適度に最適化してください。)


エラー:{「認識できる数字が見つかりませんでした。」}
Priya Jagtap

17

@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は、間の文字の数である'9''A'(ASCIIテーブル内...456789:;<=>?@ABCD...)。


16

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

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


2
CLRでコードを実行する場合、256バイトのメモリ使用量はごくわずかです。
ドルメン2013

9

これは素晴らしい投稿です。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;
}

このコードは、16進文字列が大文字のアルファ文字を使用していることを前提としており、16進文字列が小文字のアルファ文字を使用している場合は爆発します。安全のために、入力文字列を「大文字」に変換したい場合があります。
Marc Novakowski、2010年

あれは鋭い観察です。このコードはWaleedのソリューションを逆にするために作成されました。ToUpperを呼び出すと、アルゴリズムが多少遅くなりますが、小文字のアルファ文字を処理できます。
クリスF

3
Convert.ToByte(topChar + bottomChar)は、(byte)(topChar + bottomChar)として記述できます
Amir Rezaei

パフォーマンスを大幅に低下させることなく両方のケースを処理するにはhexString[i] &= ~0x20;
Ben Voigt 2014

9

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

C#:

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

VB:

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

2
その理由は、高性能ソリューションが必要な場合のパフォーマンスです。:)
リッキー

7

ここで多くの答えを重ねるわけではありませんが、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-> byte []変換が過小評価されているように感じましたが、byte []-> string角度は十分にカバーされているようです。したがって、この回答。)


1
Knuthの信奉者の方へ:数分ごとに数千の16進文字列を解析する必要があるため、これを実行しました。そのため、可能な限り高速であることが重要です(内部ループでは)。Tomalakのソリューションは、そのような解析が多数発生していない場合、特に遅くなることはありません。
Ben Mosher

5

安全なバージョン:

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 []から文字列へのアルファベットベースの変換は、バイト操作バージョンと同じくらい高速になります。

そしてもちろん、テストはリリース(最適化あり)でデバッグオプション "JIT最適化の抑制"をオフにしてコンパイルする必要があります(コードをデバッグ可能にする必要がある場合は、 "コードのみを有効にする"と同じです)。


5

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

4

拡張メソッド(免責事項:完全にテストされていないコード、BTW ...):

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

etc .. Tomalakの3つのソリューションのいずれかを使用します(最後のソリューションは文字列の拡張メソッドです)。


このような質問に答える前に、コードをテストする必要があります。
2017

3

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コードを自分で調べてください。


2
イテレータはこのコードの主な問題ではありません。あなたはベンチマークする必要がありますb.ToSting("X2")
ドルメン

2

SQLストリングに挿入する場合(コマンドパラメーターを使用していない場合):

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

場合Source == nullSource.Length == 0、私たちは、問題の先生を持っています!
Andrei Krasutski

2

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

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

2

Olipro、あなたが動作するように提案したコードを取得できませんでした。hex[i] + hex[i+1]明らかにを返しましたint

しかし、私は成功しましたが、Waleedsのコードからいくつかのヒントを得て、これを一緒にハンマーで叩きました。それは地獄のように醜いですが、私のテストによれば(パトリッジテストメカニズムを使用して)他のものと比較して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;
}

2

このバージョンの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);
    }

2

16 ビットをデコードするためにビットいじりも使用する答えがあるので、このビットいじり競争に参加します。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コードから変換されます。


うーん、本当にこれを最適化してChar[]Char内部ではなく内部で使用する必要があります...
Maarten Bodewes 2014年

C#の場合、コンパイラーを最適化するには、ループの外側ではなく、変数が使用される場所で変数を初期化することをお勧めします。どちらの方法でも同等のパフォーマンスが得られます。
Peteter

2

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

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

offset++との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]));
}

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


1

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

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

1

速度は最適化されていませんが、ほとんどの回答(.NET 4.0)よりもLINQyが多くなっています。

<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

1

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

1
HexStringToByteArray( "09")は0x02を返します。これは不良です
CoperNick

1

別の方法は、を使用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);
}

1

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

以下のToHexStringのコードは、ルックアップおよびシフトアルゴリズムの最適化された実装です。これはBehroozによるものとほとんど同じですが、foreach反復処理にa を使用することがわかり、カウンターは明示的なインデックス付けよりも高速です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の回答からのものです。

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



1

別の高速機能...

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;
}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.