byte[] en hexa

Tsunoo Rhilty

11/04/2006 à 15:31

> "0e67d6c94adc79745e462602a23cdfa3", elle me donne
"e67d6c94adc79745e462602a23cdfa3", c'est à dire qu'elle retire le "0" du
début !

effectivement car le chiffre 14 devient 0xe et non 0x0e.
Tu peux avec la fonction string.format obtenir les 0 qui te manquent (mais
là je n'ai pas la syntaxe sous la main (en C %02d) ).

...pris sur le net...

StringOut=StringOut + String.Format("{0:X2} ",InByte);

Tsunoo Rhilty

11/04/2006 à 15:32

meilleure syntaxe (pris sur le net)

//converter hex string to byte and byte to hex string
public static string ByteToString(byte[] InBytes)
{
string StringOut="";
foreach (byte InByte in InBytes)
{
StringOut=StringOut + String.Format("{0:X2} ",InByte);
}
return StringOut;

Tsunoo Rhilty

11/04/2006 à 15:40

> Et inversement une chaine hexa en byte[]

voila le code:

public static byte[] StringToByte(string InString)
{
string[] ByteStrings;
ByteStrings = InString.Split(" ".ToCharArray());
byte[] ByteOut;
ByteOut = new byte[ByteStrings.Length-1];
for (int i = 0;i==ByteStrings.Length-1;i++)
{
ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i]));
}
return ByteOut;
}
}
}

Fab

11/04/2006 à 15:44

Merci, je viens de trouver comment régler mon souci.
J'utilise :
return BitConverter.ToString(tableauDeByte).Replace("-",string.Empty);

A+

Fabrice

"Tsunoo Rhilty" a écrit :

meilleure syntaxe (pris sur le net)

//converter hex string to byte and byte to hex string
public static string ByteToString(byte[] InBytes)
{
string StringOut="";
foreach (byte InByte in InBytes)
{
StringOut=StringOut + String.Format("{0:X2} ",InByte);
}
return StringOut;

Michel Foucault

12/04/2006 à 11:18

> Ce message est au format MIME. Comme votre programme de lecture de courriers ne comprend pas

ce format, il se peut que tout ou une partie de ce message soit illisible.

--B_3227685502_456752
Content-type: text/plain;
charset="ISO-8859-1"
Content-transfer-encoding: 8bit

Je trouve les méthode proposée trop coûteuses (en temps et en mémoire) du a
l'utilisation de l'opérateur '+' avec les string et l'utilisation de
string.Replace explose lorsque les données sont trop grosses (> 1Mo)

Il est préférable d'utiliser la classe StringBuilder, et d'effectuer un
string.Replace sur des données plus petite (la méthode ToHexaString est
accompagnée d¹une méthode auxiliaire qui fait le travail.

Je n'ai pas trouvé un moyen de se passer de du string.Replace qui est aussi
coûteux qu¹inutile si la fonction formatait correctement la chaîne hexa sans
les '-'.

Je pense que la méthode FromHexaString peux également être optimisée mais je
n'ai pas trouvé mieux que ce qui était proposé (elle est 2 fois plus
coûteuse en temps que ToHexaString)

Voici le code accompagné d¹un test :

public class Program
{
 static string ToHexaString(byte[] data, int offset, int length)
 {
 return BitConverter.ToString(data, offset, length).Replace("-",
string.Empty);
 }
 public static string ToHexaString(byte[] data)
 {
 StringBuilder ret = new StringBuilder(data.Length << 1);
 int chunck = 1 << 10;
 int left = data.Length;
 int offset = 0;
 while (left > 0)
 {
 int length = Math.Min(chunck, left);
 ret.Append(ToHexaString(data, offset, length));
 offset += length;
 left -= length;
 }
 return ret.ToString ();
 }

 public static byte[] FromHexaString(string data)
 {
 int nb = data.Length / 2;
 byte[] ret = new byte[nb];
 for (int i = 0; i < nb; i++)
 {
 string str = data.Substring(i << 1, 2);
 ret[i] = Convert.ToByte(str, 16);
 }
 return ret;
 }

 public static void Main()
 {
 DateTime start = DateTime.Now;
 int size = 10 << 20;
 TimeSpan dt = DateTime.Now - start; byte[] data = new byte[size];

 Console.WriteLine("{0:0.00} Mo of random data", data.Length /
(double)(1 << 20));

 Random r = new Random();

 start = DateTime.Now;
 r.NextBytes(data);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("NextBytes : {0:0.00}s",
dt.TotalMilliseconds / 1000.0));

 start = DateTime.Now;
 string str1 = ToHexaString(data);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("ToHexa : {0:0.00}s",
dt.TotalMilliseconds / 1000.0 ));

 start = DateTime.Now;
 data = FromHexaString(str1);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("FromHexa : {0:0.00}s",
dt.TotalMilliseconds / 1000.0));

 string str2 = ToHexaString(data);

 Console.WriteLine(string.Format("{0}...{1}", str1.Substring(0, 10),
str1.Substring(str1.Length - 1 - 10)));
 Console.WriteLine(string.Format("{0}...{1}", str2.Substring(0, 10),
str2.Substring(str2.Length - 1 - 10)));
 Console.WriteLine("equals : " + (str1 == str2));
 }
}

Le 11/04/06 15:40, dans e1gbi0$1bu$, « Tsunoo Rhilty »
a écrit :

Et inversement une chaine hexa en byte[]

voila le code:

public static byte[] StringToByte(string InString)
{
string[] ByteStrings;
ByteStrings = InString.Split(" ".ToCharArray());
byte[] ByteOut;
ByteOut = new byte[ByteStrings.Length-1];
for (int i = 0;i==ByteStrings.Length-1;i++)
{
ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i]));
}
return ByteOut;
}
}
}

--B_3227685502_456752
Content-type: text/html;
charset="ISO-8859-1"
Content-transfer-encoding: quoted-printable

<HTML>
<HEAD>
<TITLE>Re: byte[] en hexa</TITLE>
</HEAD>
<BODY>
Je tr ouve les méthode proposée trop coûteuses (en temps et en mémoire) du a l'utilisation de l'opérateur '+' avec les strin g et l'utilisation de string.Replace explose lorsque les données sont trop grosses (> 1Mo) 
 
Il est préférable d'utiliser la classe StringBuilder, et d'ef fectuer un string.Replace sur des données plus petite (la méth ode ToHexaString est accompagnée d’une méthode auxiliair e qui fait le travail. 
 
Je n'ai pas trouvé un moyen de se passer de du string.Replace qui es t aussi coûteux qu’inutile si la fonction formatait correctement la chaîne hexa sans les '-'. 
 
Je pense que la méthode FromHexaString peux également ê tre optimisée mais je n'ai pas trouvé mieux que ce qui &eacute ;tait proposé (elle est 2 fois plus coûteuse en temps que ToHex aString) 
 
 
Voici le code accompagné d’un test : 
 
public class Program 
{ 
 static string ToHexaString(byte[] data, int offset, int length) 
 { 
 return BitConverter.ToString(data, offset, length).Replace("-& quot;, string.Empty); 
 } 
 public static string ToHexaString(byte[] data) 
 { 
 StringBuilder ret = new StringBuilder(data.Length << 1); 
 int chunck = 1 << 10; 
 int left = data.Length; 
 int offset = 0; 
 while (left > 0) 
 { 
 int length = Math.Min(chunck, left); 
 ret.Append(ToHexaString(data, offset, length)); 
 offset += length; 
 left -= length; 
 } 
 return ret.ToString (); 
 } 
 
 public static byte[] FromHexaString(string data) 
 { 
 int nb = data.Length / 2; 
 byte[] ret = new byte[nb]; 
 for (int i = 0; i < nb; i++) 
 { 
 string str =  data.Substring(i << 1, 2); 
 ret[i] = Convert.ToByte(str, 16); 
 } 
 return ret; 
 } 
 
 public static void Main() 
 { 
 DateTime start = DateTime.Now; 
 int size = 10 << 20; 
 TimeSpan dt = DateTime.Now - start; byte[] data = new byte[size]; 
 
 Console.WriteLine("{0:0.00} Mo of random data", data.Leng th / (double)(1 << 20)); 
 
 Random r = new Random(); 
 
 start = DateTime.Now; 
 r.NextBytes(data); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("NextBytes : {0:0.00}s", dt.TotalMilliseconds / 1000.0)); 
 
 start = DateTime.Now; 
 string str1 = ToHexaString(data); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("ToHexa : {0:0.00}s", dt. TotalMilliseconds / 1000.0 )); 
 
 start = DateTime.Now; 
 data = FromHexaString(str1); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("FromHexa : {0:0.00}s", d t.TotalMilliseconds / 1000.0));   
 
 string str2 = ToHexaString(data); 
 
 
 Console.WriteLine(string.Format("{0}...{1}", str1.Substri ng(0, 10), str1.Substring(str1.Length - 1 - 10))); 
 Console.WriteLine(string.Format("{0}...{1}", str2.Substri ng(0, 10),  str2.Substring(str2.Length - 1 - 10))); 
 Console.WriteLine("equals : " + (str1 == str2)); 
 } 
} 
 
 
Le 11/04/06 15:40, dans e1gbi0$1bu$, « Tsunoo Rhi lty » <> a écrit : 
 
> 
>> Et inversement une chaine hexa en byt e[] 
> 
> voila le code: 
> 
> 
> public static byte[] StringToByte(string InString) 
> { 
> string[] ByteStrings; 
> ByteStrings = InString.Split(" ".ToCharArray()); 
> byte[] ByteOut; 
> ByteOut = new byte[ByteStrings.Length-1]; 
> for (int i = 0;i==ByteStrings.Length-1;i++) 
> { 
> ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i])); 
> } 
> return ByteOut; 
> } 
> } 
> } 
> 
> 

</BODY>
</HTML>

--B_3227685502_456752--

> Ce message est au format MIME. Comme votre programme de lecture de courriers ne comprend pas

ce format, il se peut que tout ou une partie de ce message soit illisible.

--B_3227685502_456752
Content-type: text/plain;
charset="ISO-8859-1"
Content-transfer-encoding: 8bit

Je trouve les méthode proposée trop coûteuses (en temps et en mémoire) du a
l'utilisation de l'opérateur '+' avec les string et l'utilisation de
string.Replace explose lorsque les données sont trop grosses (> 1Mo)

Il est préférable d'utiliser la classe StringBuilder, et d'effectuer un
string.Replace sur des données plus petite (la méthode ToHexaString est
accompagnée d¹une méthode auxiliaire qui fait le travail.

Je n'ai pas trouvé un moyen de se passer de du string.Replace qui est aussi
coûteux qu¹inutile si la fonction formatait correctement la chaîne hexa sans
les '-'.

Je pense que la méthode FromHexaString peux également être optimisée mais je
n'ai pas trouvé mieux que ce qui était proposé (elle est 2 fois plus
coûteuse en temps que ToHexaString)

Voici le code accompagné d¹un test :

public class Program
{
 static string ToHexaString(byte[] data, int offset, int length)
 {
 return BitConverter.ToString(data, offset, length).Replace("-",
string.Empty);
 }
 public static string ToHexaString(byte[] data)
 {
 StringBuilder ret = new StringBuilder(data.Length << 1);
 int chunck = 1 << 10;
 int left = data.Length;
 int offset = 0;
 while (left > 0)
 {
 int length = Math.Min(chunck, left);
 ret.Append(ToHexaString(data, offset, length));
 offset += length;
 left -= length;
 }
 return ret.ToString ();
 }

 public static byte[] FromHexaString(string data)
 {
 int nb = data.Length / 2;
 byte[] ret = new byte[nb];
 for (int i = 0; i < nb; i++)
 {
 string str = data.Substring(i << 1, 2);
 ret[i] = Convert.ToByte(str, 16);
 }
 return ret;
 }

 public static void Main()
 {
 DateTime start = DateTime.Now;
 int size = 10 << 20;
 TimeSpan dt = DateTime.Now - start; byte[] data = new byte[size];

 Console.WriteLine("{0:0.00} Mo of random data", data.Length /
(double)(1 << 20));

 Random r = new Random();

 start = DateTime.Now;
 r.NextBytes(data);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("NextBytes : {0:0.00}s",
dt.TotalMilliseconds / 1000.0));

 start = DateTime.Now;
 string str1 = ToHexaString(data);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("ToHexa : {0:0.00}s",
dt.TotalMilliseconds / 1000.0 ));

 start = DateTime.Now;
 data = FromHexaString(str1);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("FromHexa : {0:0.00}s",
dt.TotalMilliseconds / 1000.0));

 string str2 = ToHexaString(data);

 Console.WriteLine(string.Format("{0}...{1}", str1.Substring(0, 10),
str1.Substring(str1.Length - 1 - 10)));
 Console.WriteLine(string.Format("{0}...{1}", str2.Substring(0, 10),
str2.Substring(str2.Length - 1 - 10)));
 Console.WriteLine("equals : " + (str1 == str2));
 }
}

Le 11/04/06 15:40, dans e1gbi0$1bu$1@news01.versatel.de, « Tsunoo Rhilty »
<fredmutter@chez.com> a écrit :

Et inversement une chaine hexa en byte[]

voila le code:

public static byte[] StringToByte(string InString)
{
string[] ByteStrings;
ByteStrings = InString.Split(" ".ToCharArray());
byte[] ByteOut;
ByteOut = new byte[ByteStrings.Length-1];
for (int i = 0;i==ByteStrings.Length-1;i++)
{
ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i]));
}
return ByteOut;
}
}
}

--B_3227685502_456752
Content-type: text/html;
charset="ISO-8859-1"
Content-transfer-encoding: quoted-printable

<HTML>
<HEAD>
<TITLE>Re: byte[] en hexa</TITLE>
</HEAD>
<BODY>
Je tr ouve les méthode proposée trop coûteuses (en temps et en mémoire) du a l'utilisation de l'opérateur '+' avec les strin g et l'utilisation de string.Replace explose lorsque les données sont trop grosses (> 1Mo) 
 
Il est préférable d'utiliser la classe StringBuilder, et d'ef fectuer un string.Replace sur des données plus petite (la méth ode ToHexaString est accompagnée d’une méthode auxiliair e qui fait le travail. 
 
Je n'ai pas trouvé un moyen de se passer de du string.Replace qui es t aussi coûteux qu’inutile si la fonction formatait correctement la chaîne hexa sans les '-'. 
 
Je pense que la méthode FromHexaString peux également ê tre optimisée mais je n'ai pas trouvé mieux que ce qui &eacute ;tait proposé (elle est 2 fois plus coûteuse en temps que ToHex aString) 
 
 
Voici le code accompagné d’un test : 
 
public class Program 
{ 
 static string ToHexaString(byte[] data, int offset, int length) 
 { 
 return BitConverter.ToString(data, offset, length).Replace("-& quot;, string.Empty); 
 } 
 public static string ToHexaString(byte[] data) 
 { 
 StringBuilder ret = new StringBuilder(data.Length << 1); 
 int chunck = 1 << 10; 
 int left = data.Length; 
 int offset = 0; 
 while (left > 0) 
 { 
 int length = Math.Min(chunck, left); 
 ret.Append(ToHexaString(data, offset, length)); 
 offset += length; 
 left -= length; 
 } 
 return ret.ToString (); 
 } 
 
 public static byte[] FromHexaString(string data) 
 { 
 int nb = data.Length / 2; 
 byte[] ret = new byte[nb]; 
 for (int i = 0; i < nb; i++) 
 { 
 string str =  data.Substring(i << 1, 2); 
 ret[i] = Convert.ToByte(str, 16); 
 } 
 return ret; 
 } 
 
 public static void Main() 
 { 
 DateTime start = DateTime.Now; 
 int size = 10 << 20; 
 TimeSpan dt = DateTime.Now - start; byte[] data = new byte[size]; 
 
 Console.WriteLine("{0:0.00} Mo of random data", data.Leng th / (double)(1 << 20)); 
 
 Random r = new Random(); 
 
 start = DateTime.Now; 
 r.NextBytes(data); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("NextBytes : {0:0.00}s", dt.TotalMilliseconds / 1000.0)); 
 
 start = DateTime.Now; 
 string str1 = ToHexaString(data); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("ToHexa : {0:0.00}s", dt. TotalMilliseconds / 1000.0 )); 
 
 start = DateTime.Now; 
 data = FromHexaString(str1); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("FromHexa : {0:0.00}s", d t.TotalMilliseconds / 1000.0));   
 
 string str2 = ToHexaString(data); 
 
 
 Console.WriteLine(string.Format("{0}...{1}", str1.Substri ng(0, 10), str1.Substring(str1.Length - 1 - 10))); 
 Console.WriteLine(string.Format("{0}...{1}", str2.Substri ng(0, 10),  str2.Substring(str2.Length - 1 - 10))); 
 Console.WriteLine("equals : " + (str1 == str2)); 
 } 
} 
 
 
Le 11/04/06 15:40, dans e1gbi0$1bu$1@news01.versatel.de, « Tsunoo Rhi lty » <fredmutter@chez.com> a écrit : 
 
> 
>> Et inversement une chaine hexa en byt e[] 
> 
> voila le code: 
> 
> 
> public static byte[] StringToByte(string InString) 
> { 
> string[] ByteStrings; 
> ByteStrings = InString.Split(" ".ToCharArray()); 
> byte[] ByteOut; 
> ByteOut = new byte[ByteStrings.Length-1]; 
> for (int i = 0;i==ByteStrings.Length-1;i++) 
> { 
> ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i])); 
> } 
> return ByteOut; 
> } 
> } 
> } 
> 
> 

</BODY>
</HTML>

--B_3227685502_456752--

Vous avez filtré cet utilisateur ! Consultez son message

> Ce message est au format MIME. Comme votre programme de lecture de courriers ne comprend pas

ce format, il se peut que tout ou une partie de ce message soit illisible.

--B_3227685502_456752
Content-type: text/plain;
charset="ISO-8859-1"
Content-transfer-encoding: 8bit

Je trouve les méthode proposée trop coûteuses (en temps et en mémoire) du a
l'utilisation de l'opérateur '+' avec les string et l'utilisation de
string.Replace explose lorsque les données sont trop grosses (> 1Mo)

Il est préférable d'utiliser la classe StringBuilder, et d'effectuer un
string.Replace sur des données plus petite (la méthode ToHexaString est
accompagnée d¹une méthode auxiliaire qui fait le travail.

Je n'ai pas trouvé un moyen de se passer de du string.Replace qui est aussi
coûteux qu¹inutile si la fonction formatait correctement la chaîne hexa sans
les '-'.

Je pense que la méthode FromHexaString peux également être optimisée mais je
n'ai pas trouvé mieux que ce qui était proposé (elle est 2 fois plus
coûteuse en temps que ToHexaString)

Voici le code accompagné d¹un test :

public class Program
{
 static string ToHexaString(byte[] data, int offset, int length)
 {
 return BitConverter.ToString(data, offset, length).Replace("-",
string.Empty);
 }
 public static string ToHexaString(byte[] data)
 {
 StringBuilder ret = new StringBuilder(data.Length << 1);
 int chunck = 1 << 10;
 int left = data.Length;
 int offset = 0;
 while (left > 0)
 {
 int length = Math.Min(chunck, left);
 ret.Append(ToHexaString(data, offset, length));
 offset += length;
 left -= length;
 }
 return ret.ToString ();
 }

 public static byte[] FromHexaString(string data)
 {
 int nb = data.Length / 2;
 byte[] ret = new byte[nb];
 for (int i = 0; i < nb; i++)
 {
 string str = data.Substring(i << 1, 2);
 ret[i] = Convert.ToByte(str, 16);
 }
 return ret;
 }

 public static void Main()
 {
 DateTime start = DateTime.Now;
 int size = 10 << 20;
 TimeSpan dt = DateTime.Now - start; byte[] data = new byte[size];

 Console.WriteLine("{0:0.00} Mo of random data", data.Length /
(double)(1 << 20));

 Random r = new Random();

 start = DateTime.Now;
 r.NextBytes(data);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("NextBytes : {0:0.00}s",
dt.TotalMilliseconds / 1000.0));

 start = DateTime.Now;
 string str1 = ToHexaString(data);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("ToHexa : {0:0.00}s",
dt.TotalMilliseconds / 1000.0 ));

 start = DateTime.Now;
 data = FromHexaString(str1);
 dt = DateTime.Now - start;
 Console.WriteLine(string.Format("FromHexa : {0:0.00}s",
dt.TotalMilliseconds / 1000.0));

 string str2 = ToHexaString(data);

 Console.WriteLine(string.Format("{0}...{1}", str1.Substring(0, 10),
str1.Substring(str1.Length - 1 - 10)));
 Console.WriteLine(string.Format("{0}...{1}", str2.Substring(0, 10),
str2.Substring(str2.Length - 1 - 10)));
 Console.WriteLine("equals : " + (str1 == str2));
 }
}

Le 11/04/06 15:40, dans e1gbi0$1bu$, « Tsunoo Rhilty »
a écrit :

Et inversement une chaine hexa en byte[]

voila le code:

public static byte[] StringToByte(string InString)
{
string[] ByteStrings;
ByteStrings = InString.Split(" ".ToCharArray());
byte[] ByteOut;
ByteOut = new byte[ByteStrings.Length-1];
for (int i = 0;i==ByteStrings.Length-1;i++)
{
ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i]));
}
return ByteOut;
}
}
}

--B_3227685502_456752
Content-type: text/html;
charset="ISO-8859-1"
Content-transfer-encoding: quoted-printable

<HTML>
<HEAD>
<TITLE>Re: byte[] en hexa</TITLE>
</HEAD>
<BODY>
Je tr ouve les méthode proposée trop coûteuses (en temps et en mémoire) du a l'utilisation de l'opérateur '+' avec les strin g et l'utilisation de string.Replace explose lorsque les données sont trop grosses (> 1Mo) 
 
Il est préférable d'utiliser la classe StringBuilder, et d'ef fectuer un string.Replace sur des données plus petite (la méth ode ToHexaString est accompagnée d’une méthode auxiliair e qui fait le travail. 
 
Je n'ai pas trouvé un moyen de se passer de du string.Replace qui es t aussi coûteux qu’inutile si la fonction formatait correctement la chaîne hexa sans les '-'. 
 
Je pense que la méthode FromHexaString peux également ê tre optimisée mais je n'ai pas trouvé mieux que ce qui &eacute ;tait proposé (elle est 2 fois plus coûteuse en temps que ToHex aString) 
 
 
Voici le code accompagné d’un test : 
 
public class Program 
{ 
 static string ToHexaString(byte[] data, int offset, int length) 
 { 
 return BitConverter.ToString(data, offset, length).Replace("-& quot;, string.Empty); 
 } 
 public static string ToHexaString(byte[] data) 
 { 
 StringBuilder ret = new StringBuilder(data.Length << 1); 
 int chunck = 1 << 10; 
 int left = data.Length; 
 int offset = 0; 
 while (left > 0) 
 { 
 int length = Math.Min(chunck, left); 
 ret.Append(ToHexaString(data, offset, length)); 
 offset += length; 
 left -= length; 
 } 
 return ret.ToString (); 
 } 
 
 public static byte[] FromHexaString(string data) 
 { 
 int nb = data.Length / 2; 
 byte[] ret = new byte[nb]; 
 for (int i = 0; i < nb; i++) 
 { 
 string str =  data.Substring(i << 1, 2); 
 ret[i] = Convert.ToByte(str, 16); 
 } 
 return ret; 
 } 
 
 public static void Main() 
 { 
 DateTime start = DateTime.Now; 
 int size = 10 << 20; 
 TimeSpan dt = DateTime.Now - start; byte[] data = new byte[size]; 
 
 Console.WriteLine("{0:0.00} Mo of random data", data.Leng th / (double)(1 << 20)); 
 
 Random r = new Random(); 
 
 start = DateTime.Now; 
 r.NextBytes(data); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("NextBytes : {0:0.00}s", dt.TotalMilliseconds / 1000.0)); 
 
 start = DateTime.Now; 
 string str1 = ToHexaString(data); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("ToHexa : {0:0.00}s", dt. TotalMilliseconds / 1000.0 )); 
 
 start = DateTime.Now; 
 data = FromHexaString(str1); 
 dt = DateTime.Now - start; 
 Console.WriteLine(string.Format("FromHexa : {0:0.00}s", d t.TotalMilliseconds / 1000.0));   
 
 string str2 = ToHexaString(data); 
 
 
 Console.WriteLine(string.Format("{0}...{1}", str1.Substri ng(0, 10), str1.Substring(str1.Length - 1 - 10))); 
 Console.WriteLine(string.Format("{0}...{1}", str2.Substri ng(0, 10),  str2.Substring(str2.Length - 1 - 10))); 
 Console.WriteLine("equals : " + (str1 == str2)); 
 } 
} 
 
 
Le 11/04/06 15:40, dans e1gbi0$1bu$, « Tsunoo Rhi lty » <> a écrit : 
 
> 
>> Et inversement une chaine hexa en byt e[] 
> 
> voila le code: 
> 
> 
> public static byte[] StringToByte(string InString) 
> { 
> string[] ByteStrings; 
> ByteStrings = InString.Split(" ".ToCharArray()); 
> byte[] ByteOut; 
> ByteOut = new byte[ByteStrings.Length-1]; 
> for (int i = 0;i==ByteStrings.Length-1;i++) 
> { 
> ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i])); 
> } 
> return ByteOut; 
> } 
> } 
> } 
> 
> 

</BODY>
</HTML>

--B_3227685502_456752--

byte[] en hexa

5 réponses

Veuillez sélectionner un problème