byte para hex string

Como faço para converter um byte[] em uma string ? Toda vez que eu tento, fico

System.Byte []

em vez do valor.

Além disso, como obtenho o valor em Hex em vez de um decimal?

Existe um método embutido para isso:

 byte[] data = { 1, 2, 4, 8, 16, 32 }; string hex = BitConverter.ToString(data); 

Resultado: 01-02-04-08-10-20

Se você quiser sem os traços, basta removê-los:

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

Resultado: 010204081020

Se você quer uma representação mais compacta, você pode usar o Base64:

 string base64 = Convert.ToBase64String(data); 

Resultado: AQIECBAg

Eu pensei que eu tentaria comparar a velocidade de cada um dos methods listados aqui para o inferno dele. Eu baseei o código de teste de velocidade disso.

O resultado é que BitConverter + String.Replace parece ser mais rápido que a maioria das outras maneiras simples. Mas a velocidade pode ser melhorada com algoritmos como ByteArrayToHexString de Nathan Moinvaziri ou ToHex de Kurt.

Eu também achei interessante que string.Concat e string.Join são muito mais lentos do que implementações de StringBuilder para seqüências de caracteres longas, mas semelhantes para matrizes mais curtas. Provavelmente devido à expansão do StringBuilder nas strings mais longas, a configuração do tamanho inicial deve negar essa diferença.

  • Pegou cada pedaço de código de uma resposta aqui:
  • BitConvertRep = Responder por Guffa, BitConverter e String.Replace (eu recomendaria para a maioria dos casos)
  • StringBuilder = Responder por Quintin Robinson, foreach char StringBuilder.Append
  • LinqConcat = Resposta de Michael Buen, string.Concat da matriz de Linq
  • LinqJoin = Resposta por mloskot, string.Juntar-se da matriz construída de Linq
  • LinqAgg = Responder por Matthew Whited, IEnumerable.Aggregate com StringBuilder
  • ToHex = Resposta por Kurt, define chars em uma matriz, usando valores de byte para obter hexadecimal
  • ByteArrayToHexString = Responder por Nathan Moinvaziri, aproximadamente a mesma velocidade que o ToHex acima, e é provavelmente mais fácil de ler (eu recomendo para velocidade)
  • ToHexFromTable = Ligado em resposta por Nathan Moinvaziri, para mim isso é quase a mesma velocidade que os 2 acima, mas requer um array de 256 strings para sempre existir

Com: LONG_STRING_LENGTH = 1000 * 1024;

  • Cálculo BitConvertRep Tempo Decorrido 27.202 ms (mais rápido embutido / simples)
  • Cálculo de StringBuilder Tempo decorrido 75.723 ms (StringBuilder no reallocate)
  • Cálculo do LinqConcat Tempo Decorrido 182.094 ms
  • Cálculo de LinqJoin Tempo decorrido 181,142 ms
  • Cálculo de LinqAgg Tempo Decorrido 93.087 ms (StringBuilder com realocação)
  • Cálculo ToHex Tempo Decorrido 19.167 ms (mais rápido)

Com: LONG_STRING_LENGTH = 100 * 1024; Resultados semelhantes

  • Cálculo BitConvertReplace Tempo decorrido 3431 ms
  • Cálculo StringBuilder Tempo Decorrido 8289 ms
  • Cálculo LinqConcat Tempo decorrido 21512 ms
  • Cálculo de LinqJoin Tempo Decorrido 19433 ms
  • Cálculo de LinqAgg Tempo Decorrido 9230 ms
  • Cálculo ToHex Tempo Decorrido 1976 ms

Com: int MANY_STRING_COUNT = 1000; int MANY_STRING_LENGTH = 1024; (Mesma contagem de bytes como primeiro teste, mas em matrizes diferentes)

  • Cálculo BitConvertReplace Tempo Decorrido 25.680 ms
  • Cálculo StringBuilder Tempo Decorrido 78,411 ms
  • Cálculo LinqConcat Tempo Decorrido 101,233 ms
  • Cálculo de LinqJoin Tempo decorrido 99.311 ms
  • Cálculo de LinqAgg Tempo Decorrido 84.660 ms
  • Cálculo ToHex Tempo Decorrido 18.221 ms

Com: int MANY_STRING_COUNT = 2000; int MANY_STRING_LENGTH = 20;

  • Cálculo BitConvertReplace Tempo Decorrido 1347 ms
  • Cálculo de StringBuilder Tempo decorrido 3234 ms
  • Cálculo do LinqConcat Tempo Decorrido 5013 ms
  • Cálculo de LinqJoin Tempo decorrido 4826 ms
  • Cálculo de LinqAgg Tempo Decorrido 3589 ms
  • Cálculo ToHex Tempo Decorrido 772 ms

Código de teste que usei:

 void Main() { int LONG_STRING_LENGTH = 100 * 1024; int MANY_STRING_COUNT = 1024; int MANY_STRING_LENGTH = 100; var source = GetRandomBytes(LONG_STRING_LENGTH); List manyString = new List(MANY_STRING_COUNT); for (int i = 0; i < MANY_STRING_COUNT; ++i) { manyString.Add(GetRandomBytes(MANY_STRING_LENGTH)); } var algorithms = new Dictionary>(); algorithms["BitConvertReplace"] = BitConv; algorithms["StringBuilder"] = StringBuilderTest; algorithms["LinqConcat"] = LinqConcat; algorithms["LinqJoin"] = LinqJoin; algorithms["LinqAgg"] = LinqAgg; algorithms["ToHex"] = ToHex; algorithms["ByteArrayToHexString"] = ByteArrayToHexString; Console.WriteLine(" === Long string test"); foreach (var pair in algorithms) { TimeAction(pair.Key + " calculation", 500, () => { pair.Value(source); }); } Console.WriteLine(" === Many string test"); foreach (var pair in algorithms) { TimeAction(pair.Key + " calculation", 500, () => { foreach (var str in manyString) { pair.Value(str); } }); } } // Define other methods and classs here static void TimeAction(string description, int iterations, Action func) { var watch = new Stopwatch(); watch.Start(); for (int i = 0; i < iterations; i++) { func(); } watch.Stop(); Console.Write(description); Console.WriteLine(" Time Elapsed {0} ms", watch.ElapsedMilliseconds); } //static byte[] GetRandomBytes(int count) { // var bytes = new byte[count]; // (new Random()).NextBytes(bytes); // return bytes; //} static Random rand = new Random(); static byte[] GetRandomBytes(int count) { var bytes = new byte[count]; rand.NextBytes(bytes); return bytes; } static string BitConv(byte[] data) { return BitConverter.ToString(data).Replace("-", string.Empty); } static string StringBuilderTest(byte[] data) { StringBuilder sb = new StringBuilder(data.Length*2); foreach (byte b in data) sb.Append(b.ToString("X2")); return sb.ToString(); } static string LinqConcat(byte[] data) { return string.Concat(data.Select(b => b.ToString("X2")).ToArray()); } static string LinqJoin(byte[] data) { return string.Join("", data.Select( bin => bin.ToString("X2") ).ToArray()); } static string LinqAgg(byte[] data) { return data.Aggregate(new StringBuilder(), (sb,v)=>sb.Append(v.ToString("X2")) ).ToString(); } static string ToHex(byte[] bytes) { char[] c = new char[bytes.Length * 2]; byte b; for(int bx = 0, cx = 0; bx < bytes.Length; ++bx, ++cx) { b = ((byte)(bytes[bx] >> 4)); c[cx] = (char)(b > 9 ? b - 10 + 'A' : b + '0'); b = ((byte)(bytes[bx] & 0x0F)); c[++cx] = (char)(b > 9 ? b - 10 + 'A' : b + '0'); } return new string(c); } public static string ByteArrayToHexString(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(); } 

Também outra resposta com um processo similar , ainda não comparei nossos resultados.

Hex, Linq-fu:

 string.Concat(ba.Select(b => b.ToString("X2")).ToArray()) 

ATUALIZAR com os tempos

Como observado por @RubenBartelink, o código que não tem uma conversão de IEnumerable para uma matriz: ba.Select(b => b.ToString("X2")) não funciona antes de 4.0, o mesmo código está agora trabalhando em 4.0.

Esse código …

 byte[] ba = { 1, 2, 4, 8, 16, 32 }; string s = string.Concat(ba.Select(b => b.ToString("X2"))); string t = string.Concat(ba.Select(b => b.ToString("X2")).ToArray()); Console.WriteLine (s); Console.WriteLine (t); 

… antes do .NET 4.0, a saída é:

 System.Linq.Enumerable+c__Iterator10`2[System.Byte,System.String] 010204081020 

No .NET 4.0 em diante, string.Concat tem uma sobrecarga que aceita IEnumerable. Portanto, na versão 4.0, o código acima terá a mesma saída para as duas variables ​​s e t

 010204081020 010204081020 

Antes de 4.0, ba.Select(b => b.ToString("X2")) vai para a sobrecarga (object arg0) , o caminho para o IEnumerable ir para uma sobrecarga adequada, ou seja, (params string[] values) , precisamos converter o IEnumerable para o array de strings. Antes de 4.0, string.Concat tem 10 funções de sobrecarga, em 4.0 é agora 12

Eu gosto de usar methods de extensão para conversões como essas, mesmo que elas apenas envolvam methods de biblioteca padrão. No caso de conversões hexadecimais, utilizo os seguintes algoritmos sintonizados manualmente (ou seja, rápidos ):

 public static string ToHex(this byte[] bytes) { char[] c = new char[bytes.Length * 2]; byte b; for(int bx = 0, cx = 0; bx < bytes.Length; ++bx, ++cx) { b = ((byte)(bytes[bx] >> 4)); c[cx] = (char)(b > 9 ? b + 0x37 + 0x20 : b + 0x30); b = ((byte)(bytes[bx] & 0x0F)); c[++cx]=(char)(b > 9 ? b + 0x37 + 0x20 : b + 0x30); } return new string(c); } public static byte[] HexToBytes(this string str) { if (str.Length == 0 || str.Length % 2 != 0) return new byte[0]; byte[] buffer = new byte[str.Length / 2]; char c; for (int bx = 0, sx = 0; bx < buffer.Length; ++bx, ++sx) { // Convert first half of byte c = str[sx]; buffer[bx] = (byte)((c > '9' ? (c > 'Z' ? (c - 'a' + 10) : (c - 'A' + 10)) : (c - '0')) < < 4); // Convert second half of byte c = str[++sx]; buffer[bx] |= (byte)(c > '9' ? (c > 'Z' ? (c - 'a' + 10) : (c - 'A' + 10)) : (c - '0')); } return buffer; } 

Aqui está outro método:

 public static string ByteArrayToHexString(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(); } public static byte[] HexStringToByteArray(string Hex) { byte[] Bytes = new byte[Hex.Length / 2]; int[] HexValue = new int[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; for (int x = 0, i = 0; i < Hex.Length; i += 2, x += 1) { Bytes[x] = (byte)(HexValue[Char.ToUpper(Hex[i + 0]) - '0'] << 4 | HexValue[Char.ToUpper(Hex[i + 1]) - '0']); } return Bytes; } 

Alternativamente, você pode pré-construir a tabela de conversão para obter resultados ainda mais rápidos:

http://www.google.com/support

Bem, eu não converto bytes em hexadecimais, então tenho que dizer que não sei se existe uma maneira melhor do que isso, mas aqui está uma maneira de fazer isso.

 StringBuilder sb = new StringBuilder(); foreach (byte b in myByteArray) sb.Append(b.ToString("X2")); string hexString = sb.ToString(); 

Eu pensei que deveria fornecer uma resposta. Do meu teste, este método é o mais rápido

 public static class Helper { public static string[] HexTbl = Enumerable.Range(0, 256).Select(v => v.ToString("X2")).ToArray(); public static string ToHex(this IEnumerable array) { StringBuilder s = new StringBuilder(); foreach (var v in array) s.Append(HexTbl[v]); return s.ToString(); } public static string ToHex(this byte[] array) { StringBuilder s = new StringBuilder(array.Length*2); foreach (var v in array) s.Append(HexTbl[v]); return s.ToString(); } } 

Métodos de extensão muito rápidos (com reversão):

 public static class ExtensionMethods { public static string ToHex(this byte[] data) { return ToHex(data, ""); } public static string ToHex(this byte[] data, string prefix) { char[] lookup = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; int i = 0, p = prefix.Length, l = data.Length; char[] c = new char[l * 2 + p]; byte d; for(; i < p; ++i) c[i] = prefix[i]; i = -1; --l; --p; while(i < l) { d = data[++i]; c[++p] = lookup[d >> 4]; c[++p] = lookup[d & 0xF]; } return new string(c, 0, c.Length); } public static byte[] FromHex(this string str) { return FromHex(str, 0, 0, 0); } public static byte[] FromHex(this string str, int offset, int step) { return FromHex(str, offset, step, 0); } public static byte[] FromHex(this string str, int offset, int step, int tail) { byte[] b = new byte[(str.Length - offset - tail + step) / (2 + step)]; byte c1, c2; int l = str.Length - tail; int s = step + 1; for(int y = 0, x = offset; x < l; ++y, x += s) { c1 = (byte)str[x]; if(c1 > 0x60) c1 -= 0x57; else if(c1 > 0x40) c1 -= 0x37; else c1 -= 0x30; c2 = (byte)str[++x]; if(c2 > 0x60) c2 -= 0x57; else if(c2 > 0x40) c2 -= 0x37; else c2 -= 0x30; b[y] = (byte)((c1 < < 4) + c2); } return b; } } 

Bate todos os outros no teste de velocidade acima:

=== Teste de sequência longa
Cálculo BitConvertReplace Tempo Decorrido 2415 ms
Cálculo StringBuilder Tempo Decorrido 5668 ms
Cálculo LinqConcat Tempo decorrido 11826 ms
Cálculo de LinqJoin Tempo Decorrido 9323 ms
Cálculo de LinqAgg Tempo Decorrido 7444 ms
Cálculo do ToHexTable Tempo Decorrido 1028 ms
Cálculo ToHexAcidzombie Tempo Decorrido 1035 ms
Cálculo ToHexPatrick Tempo decorrido 814 ms
Cálculo ToHexKurt Tempo decorrido 1604 ms
ByteArrayToHexString cálculo Tempo decorrido 1330 ms

=== Muitos testes de string
Cálculo BitConvertReplace Tempo Decorrido 2238 ms
Cálculo StringBuilder Tempo Decorrido 5393 ms
Cálculo do LinqConcat Tempo Decorrido 9043 ms
Cálculo de LinqJoin Tempo decorrido 9131 ms
Cálculo de LinqAgg Tempo Decorrido 7324 ms
Cálculo do ToHexTable Tempo Decorrido 968 ms
ToHexAcidzombie cálculo Tempo decorrido 969 ms
Cálculo ToHexPatrick Tempo Decorrido 956 ms
Cálculo ToHexKurt Tempo decorrido 1547 ms
ByteArrayToHexString calculation Tempo decorrido 1277 ms

Apenas para adicionar mais uma resposta à pilha, há uma class System.Runtime.Remoting.Metadata.W3cXsd2001.SoapHexBinary que eu usei e que pode converter bytes para e de hex:

 string hex = new SoapHexBinary(bytes).ToString(); byte[] bytes = SoapHexBinary.Parse(hex).Value; 

Não sei como ele compara (benchmark) com outras implementações, mas o IMO é bem simples – especialmente para converter de hexadecimal em bytes.

Com:

 byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x0D, 0x0E, 0x0F }; string hex = string.Empty; data.ToList().ForEach(b => hex += b.ToString("x2")); // use "X2" for uppercase hex letters Console.WriteLine(hex); 

Resultado: 0102030d0e0f

Você combina o LINQ com methods de string:

 string hex = string.Join("", bin.Select( bin => bin.ToString("X2") ).ToArray()); 

Ninguém aqui mencionou a razão pela qual você obtém a string “System.Byte []” em vez do valor, assim o farei.

Quando um object é convertido implicitamente em uma String, o programa usará como padrão o método public String ToString() que é herdado de System.Object :

 public virtual string ToString() { return this.GetType().ToString(); } 

Se você achar que está fazendo essa conversão com frequência, pode simplesmente criar uma class de wrapper e replace esse método da seguinte forma:

 public override string ToString() { // do the processing here // return the nicely formatted string } 

Agora, cada vez que você imprimir este object wrapper, você obterá seu valor em vez do valor this.GetType().ToString() .

Você tem que saber a codificação da string representada em bytes, mas você pode dizer System.Text.UTF8Encoding.GetString(bytes) ou System.Text.ASCIIEncoding.GetString(bytes) . (Estou fazendo isso da memory, então a API pode não estar exatamente correta, mas é muito próxima.)

Para a resposta à sua segunda pergunta, veja esta pergunta .

Como outros já disseram, depende da codificação dos valores na matriz de bytes. Apesar disso, você precisa ter muito cuidado com esse tipo de coisa ou pode tentar converter bytes que não são manipulados pela codificação escolhida.

Jon Skeet tem um bom artigo sobre codificação e unicode no .NET. Leitura recomendada.

Eu acho que fiz uma matriz de bytes mais rápida para string de conversor:

 public static class HexTable { private static readonly string[] table = BitConverter.ToString(Enumerable.Range(0, 256).Select(x => (byte)x).ToArray()).Split('-'); public static string ToHexTable(byte[] value) { StringBuilder sb = new StringBuilder(2 * value.Length); for (int i = 0; i < value.Length; i++) sb.Append(table[value[i]]); return sb.ToString(); } 

E o teste configurado:

 static void Main(string[] args) { const int TEST_COUNT = 10000; const int BUFFER_LENGTH = 100000; Random random = new Random(); Stopwatch sw = new Stopwatch(); Stopwatch sw2 = new Stopwatch(); byte[] buffer = new byte[BUFFER_LENGTH]; random.NextBytes(buffer); sw.Start(); for (int j = 0; j < TEST_COUNT; j++) HexTable.ToHexTable(buffer); sw.Stop(); sw2.Start(); for (int j = 0; j < TEST_COUNT; j++) ToHexChar.ToHex(buffer); sw2.Stop(); Console.WriteLine("Hex Table Elapsed Milliseconds: {0}", sw.ElapsedMilliseconds); Console.WriteLine("ToHex Elapsed Milliseconds: {0}", sw2.ElapsedMilliseconds); } 

O método ToHexChar.ToHEx () é o método ToHex () mostrado anteriormente.

Os resultados são os seguintes:

HexTable = 11808 ms ToHEx = 12168 ms

Pode não parecer muita diferença, mas ainda é mais rápido 🙂

Eu não tenho certeza se você precisa de desempenho para fazer isso, mas aqui é o método mais rápido para converter byte [] para string hexadecimal que eu posso pensar:

 static readonly char[] hexchar = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; public static string HexStr(byte[] data, int offset, int len, bool space = false) { int i = 0, k = 2; if (space) k++; var c = new char[len * k]; while (i < len) { byte d = data[offset + i]; c[i * k] = hexchar[d / 0x10]; c[i * k + 1] = hexchar[d % 0x10]; if (space && i < len - 1) c[i * k + 2] = ' '; i++; } return new string(c, 0, c.Length); } 

Bela maneira de fazer isso com o LINQ …

 var data = new byte[] { 1, 2, 4, 8, 16, 32 }; var hexString = data.Aggregate(new StringBuilder(), (sb,v)=>sb.Append(v.ToString("X2")) ).ToString(); 

Aqui está um método de extensão para matriz de bytes (byte []), por exemplo,

 var b = new byte[] { 15, 22, 255, 84, 45, 65, 7, 28, 59, 10 }; Console.WriteLine(b.ToHexString()); public static class HexByteArrayExtensionMethods { private const int AllocateThreshold = 256; private const string UpperHexChars = "0123456789ABCDEF"; private const string LowerhexChars = "0123456789abcdef"; private static string[] upperHexBytes; private static string[] lowerHexBytes; public static string ToHexString(this byte[] value) { return ToHexString(value, false); } public static string ToHexString(this byte[] value, bool upperCase) { if (value == null) { throw new ArgumentNullException("value"); } if (value.Length == 0) { return string.Empty; } if (upperCase) { if (upperHexBytes != null) { return ToHexStringFast(value, upperHexBytes); } if (value.Length > AllocateThreshold) { return ToHexStringFast(value, UpperHexBytes); } return ToHexStringSlow(value, UpperHexChars); } if (lowerHexBytes != null) { return ToHexStringFast(value, lowerHexBytes); } if (value.Length > AllocateThreshold) { return ToHexStringFast(value, LowerHexBytes); } return ToHexStringSlow(value, LowerhexChars); } private static string ToHexStringSlow(byte[] value, string hexChars) { var hex = new char[value.Length * 2]; int j = 0; for (var i = 0; i < value.Length; i++) { var b = value[i]; hex[j++] = hexChars[b >> 4]; hex[j++] = hexChars[b & 15]; } return new string(hex); } private static string ToHexStringFast(byte[] value, string[] hexBytes) { var hex = new char[value.Length * 2]; int j = 0; for (var i = 0; i < value.Length; i++) { var s = hexBytes[value[i]]; hex[j++] = s[0]; hex[j++] = s[1]; } return new string(hex); } private static string[] UpperHexBytes { get { return (upperHexBytes ?? (upperHexBytes = new[] { "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" })); } } private static string[] LowerHexBytes { get { return (lowerHexBytes ?? (lowerHexBytes = new[] { "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" })); } } } 
 private static string GuidToRaw(Guid guid) { byte[] bytes = guid.ToByteArray(); int сharCount = bytes.Length * 2; char[] chars = new char[сharCount]; int index = 0; for (int i = 0; i < сharCount; i += 2) { byte b = bytes[index++]; chars[i] = GetHexValue((int)(b / 16)); chars[i + 1] = GetHexValue((int)(b % 16)); } return new string(chars, 0, chars.Length); } private static char GetHexValue(int i) { return (char)(i < 10 ? i + 48 : i + 55); }