バイト配列を16進数の文字列に、またはその逆に変換するにはどうすればよいですか?
バイト配列を16進数の文字列に、またはその逆に変換するにはどうすればよいですか?
回答:
どちらか:
public static string ByteArrayToString(byte[] ba)
{
StringBuilder hex = new StringBuilder(ba.Length * 2);
foreach (byte b in ba)
hex.AppendFormat("{0:x2}", b);
return hex.ToString();
}
または:
public static string ByteArrayToString(byte[] ba)
{
return BitConverter.ToString(ba).Replace("-","");
}
これを行うには、さらに多くのバリエーションがあります。たとえば、こちら。
逆変換は次のようになります。
public static byte[] StringToByteArray(String hex)
{
int NumberChars = hex.Length;
byte[] bytes = new byte[NumberChars / 2];
for (int i = 0; i < NumberChars; i += 2)
bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
return bytes;
}
Substring
と組み合わせて使用するのが最良のオプションConvert.ToByte
です。詳細については、この回答を参照してください。より良いパフォーマンスが必要なConvert.ToByte
場合は、ドロップする前に回避する必要がありますSubString
。
注:2015-08-20現在の新しいリーダー。
いくつかの大まかなStopwatch
パフォーマンステスト、ランダムな文での実行(n = 61、1000回の反復)、およびProject Gutenburgテキストでの実行(n = 1、238、957、150回の反復)を通じて、さまざまな変換方法をそれぞれ実行しました。およそ最速から最速までの結果を以下に示します。すべての測定はティック(10,000ティック= 1 ms)で行われ、すべての相対ノートは[最も遅い] StringBuilder
実装と比較されます。使用したコードについては、以下を参照するか、これを実行するためのコードを保守しているテストフレームワークリポジトリをご覧ください。
警告:具体的に何かをこれらの統計に依存しないでください。それらは単にサンプルデータのサンプル実行です。本当に最高のパフォーマンスが必要な場合は、使用するものを表すデータを使用して、本番環境のニーズを表す環境でこれらのメソッドをテストしてください。
unsafe
(CodesInChaosを介して)(によって試験レポに追加airbreather)
BitConverter
(トマラック経由)
{SoapHexBinary}.ToString
(Mykroft経由)
{byte}.ToString("X2")
(を使用foreach
)(Will Deanの回答から派生)
{byte}.ToString("X2")
(を使用{IEnumerable}.Aggregate
、System.Linqが必要)(Mark経由)
Array.ConvertAll
(を使用string.Join
)(Will Dean経由)
Array.ConvertAll
(を使用string.Concat
、.NET 4.0が必要)(Will Dean経由)
{StringBuilder}.AppendFormat
(を使用foreach
)(Tomalak経由)
{StringBuilder}.AppendFormat
(を使用し{IEnumerable}.Aggregate
、System.Linqが必要です)(Tomalakの回答から派生)
ルックアップテーブルは、バイト操作をリードしています。基本的に、任意のニブルまたはバイトが16進数で何になるかを事前に計算する何らかの形式があります。次に、データをリッピングするときに、次の部分を調べて、それがどのような16進文字列であるかを確認します。次に、その値が何らかの方法で結果の文字列出力に追加されます。長い間バイト操作は、一部の開発者にとって読み取りが難しい可能性があり、最もパフォーマンスの高いアプローチでした。
あなたの最善の策は、いくつかの代表的なデータを見つけて、本番のような環境でそれを試すことです。異なるメモリ制約がある場合は、割り当てが少ない方法よりも高速ですが、より多くのメモリを消費する方法をお勧めします。
使用したテストコードを自由に試してみてください。ここにはバージョンが含まれていますが、リポジトリを複製して独自のメソッドを追加してください。何か面白いものを見つけたり、使用するテストフレームワークの改善に協力したい場合は、プルリクエストを送信してください。
Func<byte[], string>
)を/Tests/ConvertByteArrayToHexString/Test.csに追加します。TestCandidates
同じクラスの戻り値に追加します。GenerateTestInput
同じクラスのコメントを切り替えて、必要な入力バージョン(文またはテキスト)を実行していることを確認してください。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();
}
分析に対するWaleedの回答を追加しました。かなり速いです。
string.Concat
Array.ConvertAll
完全性のためにバリアントを追加しました(.NET 4.0が必要です)。string.Join
バージョンと同等。
テストリポジトリには、などのバリアントがさらに含まれていStringBuilder.Append(b.ToString("X2"))
ます。結果を混乱させるものはありません。たとえばforeach
はより高速です{IEnumerable}.Aggregate
が、それBitConverter
でも勝ちます。
SoapHexBinary
分析へのMykroftの回答が追加され、3位になりました。
CodesInChaosのバイト操作の回答を追加しました。これは(テキストの大きなブロックで大幅なマージンで)1位になりました。
Nathan Moinvaziriの検索回答とBrian Lambertのブログからのバリアントを追加しました。どちらもかなり高速ですが、私が使用したテストマシン(AMD Phenom 9750)ではリードしていません。
@CodesInChaosの新しいバイトベースのルックアップ回答が追加されました。文テストと全文テストの両方で主導権を握ったようです。
この回答のリポジトリにairbreatherの最適化とunsafe
バリアントを追加しました。安全でないゲームでプレイしたい場合は、短い文字列と大きなテキストの両方で、以前のトップ勝者よりも大幅にパフォーマンスを向上させることができます。
bytes.ToHexStringAtLudicrousSpeed()
。
SoapHexBinaryと呼ばれるクラスがあり、まさにあなたが望むものを実行します。
using System.Runtime.Remoting.Metadata.W3cXsd2001;
public static byte[] GetStringToBytes(string value)
{
SoapHexBinary shb = SoapHexBinary.Parse(value);
return shb.Value;
}
public static string GetBytesToString(byte[] value)
{
SoapHexBinary shb = new SoapHexBinary(value);
return shb.ToString();
}
暗号化コードを記述する場合、データ依存のタイミングがサイドチャネル攻撃につながる可能性があるため、ランタイムがデータに依存しないようにするために、データ依存のブランチとテーブルのルックアップを回避するのが一般的です。
また、かなり高速です。
static string ByteToHexBitFiddle(byte[] bytes)
{
char[] c = new char[bytes.Length * 2];
int b;
for (int i = 0; i < bytes.Length; i++) {
b = bytes[i] >> 4;
c[i * 2] = (char)(55 + b + (((b-10)>>31)&-7));
b = bytes[i] & 0xF;
c[i * 2 + 1] = (char)(55 + b + (((b-10)>>31)&-7));
}
return new string(c);
}
Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn
ここに入るあなたがたは、すべての希望を捨てる
奇妙なビットのいじりの説明:
bytes[i] >> 4
バイトの高いニブルをbytes[i] & 0xF
抽出するバイトの低いニブルを抽出するb - 10
< 0
値のためのb < 10
小数の桁になるだろう、>= 0
値のためb > 10
からの手紙になるだろう、A
とF
。i >> 31
符号付き32ビット整数で使用すると、符号拡張により符号が抽出されます。それは次のようになります-1
のためにi < 0
と0
のためにi >= 0
。(b-10)>>31
が0
文字と-1
数字になることがわかります。0
、10〜15 b
の範囲になります。これをA
(65)〜F
(70)にマッピングすると、55('A'-10
)が追加されます。b
0から9の範囲から0
(48)から9
(57)の範囲にマップするように最後の加数を適応させたいと思います。つまり、-7('0' - 55
)になる必要があります。& -7
ため(0 & -7) == 0
、代わりにsince およびを使用でき(-1 & -7) == -7
ます。その他の考慮事項:
c
測定からそれを計算するi
方が安価であることを示しているためです。i < bytes.Length
ループの上限とまったく同じように使用することで、JITterはの境界チェックを排除できるbytes[i]
ため、そのバリアントを選択しました。b
intを作成すると、バイトとの間の不要な変換が可能になります。hex string
にbyte[] array
?
87 + b + (((b-10)>>31)&-39)
byte[] array
、文字通りのバイト配列の配列を意味し、」、またはbyte[][]
。ただ面白がっているだけでした。
より柔軟にしたいがBitConverter
、1990年代スタイルの不格好な明示的なループを望まない場合は、次のようにできます。
String.Join(String.Empty, Array.ConvertAll(bytes, x => x.ToString("X2")));
または、.NET 4.0を使用している場合:
String.Concat(Array.ConvertAll(bytes, x => x.ToString("X2")));
(後者は元の投稿へのコメントから。)
別のルックアップテーブルベースのアプローチ。これは、ニブルごとのルックアップテーブルではなく、バイトごとに1つのルックアップテーブルのみを使用します。
private static readonly uint[] _lookup32 = CreateLookup32();
private static uint[] CreateLookup32()
{
var result = new uint[256];
for (int i = 0; i < 256; i++)
{
string s=i.ToString("X2");
result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
}
return result;
}
private static string ByteArrayToHexViaLookup32(byte[] bytes)
{
var lookup32 = _lookup32;
var result = new char[bytes.Length * 2];
for (int i = 0; i < bytes.Length; i++)
{
var val = lookup32[bytes[i]];
result[2*i] = (char)val;
result[2*i + 1] = (char) (val >> 16);
}
return new string(result);
}
私も使用して、このの変異体をテストしたushort
、struct{char X1, X2}
、struct{byte X1, X2}
、ルックアップテーブルに。
コンパイルターゲット(x86、X64)に応じて、パフォーマンスはほぼ同じか、このバリアントよりもわずかに低速でした。
そしてさらに高いパフォーマンスのために、そのunsafe
兄弟:
private static readonly uint[] _lookup32Unsafe = CreateLookup32Unsafe();
private static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_lookup32Unsafe,GCHandleType.Pinned).AddrOfPinnedObject();
private static uint[] CreateLookup32Unsafe()
{
var result = new uint[256];
for (int i = 0; i < 256; i++)
{
string s=i.ToString("X2");
if(BitConverter.IsLittleEndian)
result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
else
result[i] = ((uint)s[1]) + ((uint)s[0] << 16);
}
return result;
}
public static string ByteArrayToHexViaLookup32Unsafe(byte[] bytes)
{
var lookupP = _lookup32UnsafeP;
var result = new char[bytes.Length * 2];
fixed(byte* bytesP = bytes)
fixed (char* resultP = result)
{
uint* resultP2 = (uint*)resultP;
for (int i = 0; i < bytes.Length; i++)
{
resultP2[i] = lookupP[bytesP[i]];
}
}
return new string(result);
}
または、文字列に直接書き込むことが許容できると考える場合:
public static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes)
{
var lookupP = _lookup32UnsafeP;
var result = new string((char)0, bytes.Length * 2);
fixed (byte* bytesP = bytes)
fixed (char* resultP = result)
{
uint* resultP2 = (uint*)resultP;
for (int i = 0; i < bytes.Length; i++)
{
resultP2[i] = lookupP[bytesP[i]];
}
}
return result;
}
Span
代わりに今使えるのかしらunsafe
?
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
今日、まったく同じ問題に遭遇し、このコードに出くわしました。
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倍高速でした(パトリッジの投稿によると最速)。
これが答えです改訂4のTomalakの非常に人気のある答え(およびそれ以降の編集)。
この編集が間違っている場合を取り上げ、元に戻すことができる理由を説明します。途中で、いくつかの内部について1つまたは2つのことを学び、時期尚早な最適化が実際に何であるか、またそれがどのようにあなたを食い止めることができるかについてのさらに別の例を見るかもしれません。
TL; DR:だけの使用Convert.ToByte
やString.Substring
お急ぎ(以下、「オリジナルコード」)にいる場合は、再実装しない場合、それは最高の組み合わせですConvert.ToByte
。パフォーマンスConvert.ToByte
が必要な場合は使用しない、より高度なもの(他の回答を参照)を使用します。この回答のコメントで誰かがこれについて何か面白いことを言っているのでない限り、と組み合わせること以外は何も使用しないでください。String.Substring
Convert.ToByte
警告:フレームワークにオーバーロードが実装されている場合、この回答は廃止される可能性がありConvert.ToByte(char[], Int32)
ます。これはすぐには起こりそうにありません。
原則として、「時期尚早」がいつであるかは誰にもわからないため、「時期尚早に最適化しないでください」とはあまり言いたくありません。最適化するかどうかを決定する際に考慮しなければならない唯一のことは、「最適化アプローチを適切に調査するための時間とリソースはありますか?」です。そうでない場合は、早すぎます。プロジェクトが成熟するまで、またはパフォーマンスが必要になるまで待機します(本当に必要な場合は、時間を確保します)。それまでの間、代わりに機能する可能性のある最も単純なことを行ってください。
元のコード:
public static byte[] HexadecimalStringToByteArray_Original(string input)
{
var outputLength = input.Length / 2;
var output = new byte[outputLength];
for (var i = 0; i < outputLength; i++)
output[i] = Convert.ToByte(input.Substring(i * 2, 2), 16);
return output;
}
リビジョン4:
public static byte[] HexadecimalStringToByteArray_Rev4(string input)
{
var outputLength = input.Length / 2;
var output = new byte[outputLength];
using (var sr = new StringReader(input))
{
for (var i = 0; i < outputLength; i++)
output[i] = Convert.ToByte(new string(new char[2] { (char)sr.Read(), (char)sr.Read() }), 16);
}
return output;
}
リビジョンは回避String.Substring
し、StringReader
代わりに使用します。与えられた理由は:
編集:次のように、シングルパスパーサーを使用して、長い文字列のパフォーマンスを向上させることができます。
さて、の参照コードをString.Substring
見ると、明らかに「シングルパス」になっています。そして、なぜそれはいけないのですか?サロゲートペアではなく、バイトレベルで動作します。
ただし、新しい文字列は割り当てられますが、Convert.ToByte
とにかく渡すには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
が自分で宣言できる並列インデックス(内部)j
、冗長な長さ変数(内部_length
)、および入力への冗長な参照である文字列リーダーです。文字列(内部_s
)。言い換えれば、それは役に立たないです。
どのようにRead
「読み取る」のか疑問に思う場合は、コードを見てください。コードが行うのはString.CopyTo
、入力文字列を呼び出すことだけです。残りは、私たちが必要としない値を維持するための単なる簿記のオーバーヘッドです。
そのため、すでにストリングリーダーを削除し、CopyTo
自分自身を呼び出してください。よりシンプルで、明確で、効率的です。
public static byte[] HexadecimalStringToByteArray(string input)
{
var outputLength = input.Length / 2;
var output = new byte[outputLength];
var numeral = new char[2];
for (int i = 0, j = 0; i < outputLength; i++, j += 2)
{
input.CopyTo(j, numeral, 0, 2);
output[i] = Convert.ToByte(new string(numeral), 16);
}
return output;
}
本当にj
2ずつ平行して増分するインデックスが必要i
ですか?もちろん、i
2を掛けるだけではありません(コンパイラーはこれを加算に最適化できるはずです)。
public static byte[] HexadecimalStringToByteArray_BestEffort(string input)
{
var outputLength = input.Length / 2;
var output = new byte[outputLength];
var numeral = new char[2];
for (int i = 0; i < outputLength; i++)
{
input.CopyTo(i * 2, numeral, 0, 2);
output[i] = Convert.ToByte(new string(numeral), 16);
}
return output;
}
ソリューションは現在どのように見えますか?最初とまったく同じようにString.Substring
、文字列を割り当ててデータをコピーするのではなく、16進数をコピーする中間配列を使用してから、自分で文字列を割り当ててからデータを再度コピーします配列と文字列(文字列コンストラクターで渡す場合)。文字列が既にインターンプールにある場合、2番目のコピーは最適化される可能性がありますがString.Substring
、これらの場合も回避できます。
実際、String.Substring
もう一度見ると、文字列の構築方法に関する低レベルの内部知識を使用して、通常よりも速く文字列を割り当てることがわかります。また、CopyTo
直接使用する同じコードをインラインでインライン化して回避しています。呼び出しオーバーヘッド。
String.Substring
手動による方法
結論?使用したい場合Convert.ToByte(String, Int32)
(その機能を自分で再実装したくないため)、打ち負かす方法がないようですString.Substring
。あなたがすることはすべて、輪の中で走って、車輪を再発明することです(次善の材料でのみ)。
極端なパフォーマンスが必要ない場合は、Convert.ToByte
andの使用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
楽しんで!(しかし、適度に最適化してください。)
@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...
)。
この問題は、ルックアップテーブルを使用して解決することもできます。これには、エンコーダとデコーダの両方に少量のスタティックメモリが必要です。ただし、この方法は高速です。
私のソリューションでは、エンコードテーブルに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を超える場合)。ストリームまたは配列のデコード/エンコードのメソッドを実装する必要があります。これは概念の証明にすぎません。
これは素晴らしい投稿です。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;
}
hexString[i] &= ~0x20;
なぜ複雑にするのですか?これはVisual Studio 2008では簡単です。
C#:
string hex = BitConverter.ToString(YourByteArray).Replace("-", "");
VB:
Dim hex As String = BitConverter.ToString(YourByteArray).Replace("-", "")
ここで多くの答えを重ねるわけではありませんが、16進文字列パーサーのかなり最適な(受け入れられるものの約4.5倍)、簡単な実装を見つけました。最初に、私のテストからの出力(最初のバッチは私の実装です):
Give me that string:
04c63f7842740c77e545bb0b2ade90b384f119f6ab57b680b7aa575a2f40939f
Time to parse 100,000 times: 50.4192 ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F
Accepted answer: (StringToByteArray)
Time to parse 100000 times: 233.1264ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F
With Mono's implementation:
Time to parse 100000 times: 777.2544ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F
With SoapHexBinary:
Time to parse 100000 times: 845.1456ms
Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
7-B6-80-B7-AA-57-5A-2F-40-93-9F
base64および 'BitConverter'd'行は、正確性をテストするためにあります。それらは等しいことに注意してください。
実装:
public static byte[] ToByteArrayFromHex(string hexString)
{
if (hexString.Length % 2 != 0) throw new ArgumentException("String must have an even length");
var array = new byte[hexString.Length / 2];
for (int i = 0; i < hexString.Length; i += 2)
{
array[i/2] = ByteFromTwoChars(hexString[i], hexString[i + 1]);
}
return array;
}
private static byte ByteFromTwoChars(char p, char p_2)
{
byte ret;
if (p <= '9' && p >= '0')
{
ret = (byte) ((p - '0') << 4);
}
else if (p <= 'f' && p >= 'a')
{
ret = (byte) ((p - 'a' + 10) << 4);
}
else if (p <= 'F' && p >= 'A')
{
ret = (byte) ((p - 'A' + 10) << 4);
} else throw new ArgumentException("Char is not a hex digit: " + p,"p");
if (p_2 <= '9' && p_2 >= '0')
{
ret |= (byte) ((p_2 - '0'));
}
else if (p_2 <= 'f' && p_2 >= 'a')
{
ret |= (byte) ((p_2 - 'a' + 10));
}
else if (p_2 <= 'F' && p_2 >= 'A')
{
ret |= (byte) ((p_2 - 'A' + 10));
} else throw new ArgumentException("Char is not a hex digit: " + p_2, "p_2");
return ret;
}
私はいくつかのものを試してみましたunsafe
し、(明らかに冗長)文字・ツー・ニブル移動するif
別の方法と配列を、これは、それが持って最速でした。
(これで問題の半分が解決されると思います。string-> byte []変換が過小評価されているように感じましたが、byte []-> string角度は十分にカバーされているようです。したがって、この回答。)
安全なバージョン:
public static class HexHelper
{
[System.Diagnostics.Contracts.Pure]
public static string ToHex(this byte[] value)
{
if (value == null)
throw new ArgumentNullException("value");
const string hexAlphabet = @"0123456789ABCDEF";
var chars = new char[checked(value.Length * 2)];
unchecked
{
for (int i = 0; i < value.Length; i++)
{
chars[i * 2] = hexAlphabet[value[i] >> 4];
chars[i * 2 + 1] = hexAlphabet[value[i] & 0xF];
}
}
return new string(chars);
}
[System.Diagnostics.Contracts.Pure]
public static byte[] FromHex(this string value)
{
if (value == null)
throw new ArgumentNullException("value");
if (value.Length % 2 != 0)
throw new ArgumentException("Hexadecimal value length must be even.", "value");
unchecked
{
byte[] result = new byte[value.Length / 2];
for (int i = 0; i < result.Length; i++)
{
// 0(48) - 9(57) -> 0 - 9
// A(65) - F(70) -> 10 - 15
int b = value[i * 2]; // High 4 bits.
int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
b = value[i * 2 + 1]; // Low 4 bits.
val += (b - '0') + ((('9' - b) >> 31) & -7);
result[i] = checked((byte)val);
}
return result;
}
}
}
安全でないバージョンパフォーマンスを好み、安全でないことを恐れない人向け。ToHexが約35%、FromHexが10%高速です。
public static class HexUnsafeHelper
{
[System.Diagnostics.Contracts.Pure]
public static unsafe string ToHex(this byte[] value)
{
if (value == null)
throw new ArgumentNullException("value");
const string alphabet = @"0123456789ABCDEF";
string result = new string(' ', checked(value.Length * 2));
fixed (char* alphabetPtr = alphabet)
fixed (char* resultPtr = result)
{
char* ptr = resultPtr;
unchecked
{
for (int i = 0; i < value.Length; i++)
{
*ptr++ = *(alphabetPtr + (value[i] >> 4));
*ptr++ = *(alphabetPtr + (value[i] & 0xF));
}
}
}
return result;
}
[System.Diagnostics.Contracts.Pure]
public static unsafe byte[] FromHex(this string value)
{
if (value == null)
throw new ArgumentNullException("value");
if (value.Length % 2 != 0)
throw new ArgumentException("Hexadecimal value length must be even.", "value");
unchecked
{
byte[] result = new byte[value.Length / 2];
fixed (char* valuePtr = value)
{
char* valPtr = valuePtr;
for (int i = 0; i < result.Length; i++)
{
// 0(48) - 9(57) -> 0 - 9
// A(65) - F(70) -> 10 - 15
int b = *valPtr++; // High 4 bits.
int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
b = *valPtr++; // Low 4 bits.
val += (b - '0') + ((('9' - b) >> 31) & -7);
result[i] = checked((byte)val);
}
}
return result;
}
}
}
ところで、 変換された変換関数が間違っているたびにアルファベットを初期化するベンチマークテストでは、アルファベットはconst(文字列の場合)または静的な読み取り専用(char []の場合)でなければなりません。次に、byte []から文字列へのアルファベットベースの変換は、バイト操作バージョンと同じくらい高速になります。
そしてもちろん、テストはリリース(最適化あり)でデバッグオプション "JIT最適化の抑制"をオフにしてコンパイルする必要があります(コードをデバッグ可能にする必要がある場合は、 "コードのみを有効にする"と同じです)。
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);
}
拡張メソッド(免責事項:完全にテストされていないコード、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つのソリューションのいずれかを使用します(最後のソリューションは文字列の拡張メソッドです)。
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コードを自分で調べてください。
b.ToSting("X2")
。
SQLストリングに挿入する場合(コマンドパラメーターを使用していない場合):
public static String ByteArrayToSQLHexString(byte[] Source)
{
return = "0x" + BitConverter.ToString(Source).Replace("-", "");
}
Source == null
やSource.Length == 0
、私たちは、問題の先生を持っています!
速度の点では、これはここでの何よりも優れているようです:
public static string ToHexString(byte[] data) {
byte b;
int i, j, k;
int l = data.Length;
char[] r = new char[l * 2];
for (i = 0, j = 0; i < l; ++i) {
b = data[i];
k = b >> 4;
r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
k = b & 15;
r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
}
return new string(r);
}
Olipro、あなたが動作するように提案したコードを取得できませんでした。hex[i] + hex[i+1]
明らかにを返しましたint
。
しかし、私は成功しましたが、Waleedsのコードからいくつかのヒントを得て、これを一緒にハンマーで叩きました。それは地獄のように醜いですが、私のテストによれば(パトリッジテストメカニズムを使用して)他のものと比較して1/3の時間で動作し、実行するようです。入力サイズによって異なります。?:sを最初から0-9に分離するように切り替えると、文字よりも数字の数が多いため、結果はわずかに速くなります。
public static byte[] StringToByteArray2(string hex)
{
byte[] bytes = new byte[hex.Length/2];
int bl = bytes.Length;
for (int i = 0; i < bl; ++i)
{
bytes[i] = (byte)((hex[2 * i] > 'F' ? hex[2 * i] - 0x57 : hex[2 * i] > '9' ? hex[2 * i] - 0x37 : hex[2 * i] - 0x30) << 4);
bytes[i] |= (byte)(hex[2 * i + 1] > 'F' ? hex[2 * i + 1] - 0x57 : hex[2 * i + 1] > '9' ? hex[2 * i + 1] - 0x37 : hex[2 * i + 1] - 0x30);
}
return bytes;
}
このバージョンのByteArrayToHexViaByteManipulationの方が高速である可能性があります。
私の報告から:
...
static private readonly char[] hexAlphabet = new char[]
{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
static string ByteArrayToHexViaByteManipulation3(byte[] bytes)
{
char[] c = new char[bytes.Length * 2];
byte b;
for (int i = 0; i < bytes.Length; i++)
{
b = ((byte)(bytes[i] >> 4));
c[i * 2] = hexAlphabet[b];
b = ((byte)(bytes[i] & 0xF));
c[i * 2 + 1] = hexAlphabet[b];
}
return new string(c);
}
そして、これは最適化だと思います:
static private readonly char[] hexAlphabet = new char[]
{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
static string ByteArrayToHexViaByteManipulation4(byte[] bytes)
{
char[] c = new char[bytes.Length * 2];
for (int i = 0, ptr = 0; i < bytes.Length; i++, ptr += 2)
{
byte b = bytes[i];
c[ptr] = hexAlphabet[b >> 4];
c[ptr + 1] = hexAlphabet[b & 0xF];
}
return new string(c);
}
16 ビットをデコードするためにビットいじりも使用する答えがあるので、このビットいじり競争に参加します。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
内部ではなく内部で使用する必要があります...
パフォーマンスについては、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]));
}
これは私の頭の上にあり、テストもベンチマークもされていません。
多様性のさらに別のバリエーション:
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;
}
速度は最適化されていませんが、ほとんどの回答(.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
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;
}
別の方法は、を使用stackalloc
してGCのメモリ負荷を軽減することです。
static string ByteToHexBitFiddle(byte[] bytes)
{
var c = stackalloc char[bytes.Length * 2 + 1];
int b;
for (int i = 0; i < bytes.Length; ++i)
{
b = bytes[i] >> 4;
c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7));
b = bytes[i] & 0xF;
c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7));
}
c[bytes.Length * 2 ] = '\0';
return new string(c);
}
これが私のショットです。文字列とバイトを拡張する拡張クラスのペアを作成しました。ラージファイルテストでは、パフォーマンスはバイト操作2に匹敵します。
以下のToHexStringのコードは、ルックアップおよびシフトアルゴリズムの最適化された実装です。これはBehroozによるものとほとんど同じですが、foreach
反復処理に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
上記の結果に基づいて、次のように結論付けても安全と思われます。
コードは次のとおりです。
using System;
namespace ConversionExtensions
{
public static class ByteArrayExtensions
{
private readonly static char[] digits = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
public static string ToHexString(this byte[] bytes)
{
char[] hex = new char[bytes.Length * 2];
int index = 0;
foreach (byte b in bytes)
{
hex[index++] = digits[b >> 4];
hex[index++] = digits[b & 0x0F];
}
return new string(hex);
}
}
}
using System;
using System.IO;
namespace ConversionExtensions
{
public static class StringExtensions
{
public static byte[] ToBytes(this string hexString)
{
if (!string.IsNullOrEmpty(hexString) && hexString.Length % 2 != 0)
{
throw new FormatException("Hexadecimal string must not be empty and must contain an even number of digits to be valid.");
}
hexString = hexString.ToUpperInvariant();
byte[] data = new byte[hexString.Length / 2];
for (int index = 0; index < hexString.Length; index += 2)
{
int highDigitValue = hexString[index] <= '9' ? hexString[index] - '0' : hexString[index] - 'A' + 10;
int lowDigitValue = hexString[index + 1] <= '9' ? hexString[index + 1] - '0' : hexString[index + 1] - 'A' + 10;
if (highDigitValue < 0 || lowDigitValue < 0 || highDigitValue > 15 || lowDigitValue > 15)
{
throw new FormatException("An invalid digit was encountered. Valid hexadecimal digits are 0-9 and A-F.");
}
else
{
byte value = (byte)((highDigitValue << 4) | (lowDigitValue & 0x0F));
data[index / 2] = value;
}
}
return data;
}
}
}
以下は、コードをマシンの@patridgeのテストプロジェクトに配置したときに得られたテスト結果です。16進数からバイト配列に変換するためのテストも追加しました。コードを実行したテスト実行は、ByteArrayToHexViaOptimizedLookupAndShiftとHexToByteArrayViaByteManipulationです。HexToByteArrayViaConvertToByteはXXXXから取得されました。HexToByteArrayViaSoapHexBinaryは、@ Mykroftの回答からのものです。
Intel Pentium III Xeonプロセッサ
Cores: 4 <br/> Current Clock Speed: 1576 <br/> Max Clock Speed: 3092 <br/>
バイトの配列を16進数の文字列表現に変換する
ByteArrayToHexViaByteManipulation2:39,366.64の平均ティック(1000ラン以上)、22.4X
ByteArrayToHexViaOptimizedLookupAndShift:41,588.64平均ティック(1000回以上の実行)、21.2X
ByteArrayToHexViaLookup:55,509.56の平均ティック(1000回以上の実行)、15.9X
ByteArrayToHexViaByteManipulation:65,349.12の平均ティック(1000ラン以上)、13.5X
ByteArrayToHexViaLookupAndShift:86,926.87平均ティック(1000回以上の実行)、10.2X
ByteArrayToHexStringViaBitConverter:139,353.73平均ティック(1000回以上の実行)、6.3X
ByteArrayToHexViaSoapHexBinary:314,598.77平均ティック(1000回以上の実行)、2.8X
ByteArrayToHexStringViaStringBuilderForEachByteToString:344,264.63の平均ティック(1000回以上の実行)、2.6X
ByteArrayToHexStringViaStringBuilderAggregateByteToString:382,623.44の平均ティック(1000回以上の実行)、2.3X
ByteArrayToHexStringViaStringBuilderForEachAppendFormat:818,111.95平均ティック(1000回以上の実行)、1.1X
ByteArrayToHexStringViaStringConcatArrayConvertAll:839,244.84平均ティック(1000回以上の実行)、1.1X
ByteArrayToHexStringViaStringBuilderAggregateAppendFormat:867,303.98平均ティック(1000回以上の実行)、1.0X
ByteArrayToHexStringViaStringJoinArrayConvertAll:882,710.28平均ティック(1000回以上の実行)、1.0X
別の高速機能...
private static readonly byte[] HexNibble = new byte[] {
0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
0x8, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
};
public static byte[] HexStringToByteArray( string str )
{
int byteCount = str.Length >> 1;
byte[] result = new byte[byteCount + (str.Length & 1)];
for( int i = 0; i < byteCount; i++ )
result[i] = (byte) (HexNibble[str[i << 1] - 48] << 4 | HexNibble[str[(i << 1) + 1] - 48]);
if( (str.Length & 1) != 0 )
result[byteCount] = (byte) HexNibble[str[str.Length - 1] - 48];
return result;
}