|
|
Can anyone tell me what does it mean by :
for (int i=0; i<byteArray.Length; i++)
{
temp += byteArray[i].ToString("D3") + " ";
}
Why D3?
I am beginner in programing. So, I am unsure about this term.
Your help will be greatly appreciated.
Thanks
|
|
|
|
|
That is a C# string format code, similar to printf.
What it means is, convert byteArray[i] to a string and format the string as a 'D'ecimal number with exactly '3' digits.
|
|
|
|
|
Is there any license for the use of this code ?
|
|
|
|
|
can some one send me the built executable? I am not able to build it
vikram.patwardhan@gmail.com
|
|
|
|
|
Processing a large file went from more than 8 minutes to less than a second when I modified GetBytes() as shown below. A profiler showed that
System.String.Concat(Object, Object)
was using most of the CPU time. Rather than concatenate or StringBuild a temporary string of valid hex digits, I just process them as they occur in the input hexString.
So far all tests have passed...
(I had no need for out int discarded and removed it.)
public static byte[] GetBytes(string hexString) {
if (null == hexString)
return new byte[0];
if (hexString.Length < 2)
return new byte[0];
List<byte> byteList = new List<byte>(hexString.Length/2);
char c1 = 'x';
bool have1 = false;
for (int i = 0; i < hexString.Length; i++) {
char c = hexString[i];
if (Uri.IsHexDigit(c))
if (have1) {
byteList.Add(HexToByte(new string(new char[] {c1, c})));
have1 = false;
} else {
have1 = true;
c1 = c;
}
}
return byteList.ToArray();
}
</byte>
modified on Thursday, January 22, 2009 5:42 PM
|
|
|
|
|
I got a error from your code. (VS2008)
Fix:
Find:
List<byte> byteList = new List(hexString.Length/2);
Replace:
List<byte> byteList = new List<byte>(hexString.Length / 2);
|
|
|
|
|
I looked on internet and found your article.
Really good. Thanks.
|
|
|
|
|
Thanks in advance.
I'm trying byte[] imgByte = null;
I need to return it as some empty byte array.
|
|
|
|
|
What about the speed and simplicity of my function :
private Byte[] hexStringToByteArray(string hexinput)
{
if (hexinput == String.Empty)
return null;
if (hexinput.Length % 2 == 1)
hexinput = "0" + hexinput;
int arr_size = hexinput.Length / 2;
Byte[] myBytes = new Byte[arr_size];
for (int i = 0; i < arr_size; i++)
myBytes[i] = Convert.ToByte(hexinput.Substring(i * 2, 2), 16);
return myBytes;
}
private void test()
{
string hex = "15900fF654654651516ABCDEFFF";
byte[] res = this.hexStringToByteArray(hex);
string disp = String.Empty;
foreach (byte b in res)
disp += b.ToString("X2") + " - " + b.ToString() + Environment.NewLine;
MessageBox.Show(disp);
}
"Nothing happens unless first a dream...", Carl Sandburg
-- modified at 7:14 Monday 12th November, 2007
|
|
|
|
|
your source code was inspirational in my project..
i solved my problem, about from stringHex to byte array..
later that a great many fight..
and i find what is problem..
when i was encrypt my data :
public string WriteHex(byte[] array)
{
string from_array=null;
for (int i = 0; i < array.Length; i++)
from_array+=array[i].ToString("X");
/* there is single X, its wrong! that's right from_array+=array[i].ToString("X2"); .... */
return from_array;
}
|
|
|
|
|
May be BitConverter do most of this, from and to string.
regards
Michail
http://www.mommosoft.com
|
|
|
|
|
Int32.Parse( "fae0b7" ,System.Globalization.NumberStyles.AllowHexSpecifier);
|
|
|
|
|
int32.parse does not return a byte[]
...
|
|
|
|
|
Then you should try to learn loops
|
|
|
|
|
Exactly. Here is an example of a function that does return a byte[] using this method.
private static byte[] HexToData(string hexString)
{
if (hexString == null)
return null;
if (hexString.Length % 2 == 1)
hexString = '0' + hexString;
byte[] data = new byte[hexString.Length / 2];
for (int i = 0; i < data.Length; i++)
data[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
return data;
}
It is better to use this than the code from the article.
Edit: Changed byte.Parse(string, System.Globalization.NumberStyles.HexNumber) to Convert.ToByte(string, 16). This gives about a 60% to 65% performance increase to the entire method.
modified on Wednesday, April 16, 2008 11:18 AM
|
|
|
|
|
What about the code:
<br />
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();<br />
byte[] key = new byte[1024];<br />
rng.GetNonZeroBytes(key);<br />
<br />
string ba_as_string = BitConverter.ToString(key);<br />
<br />
string[] hexaInfo = ba_as_string.Split('-');<br />
System.Collections.ArrayList ba1 = new System.Collections.ArrayList();<br />
foreach (string hexa in hexaInfo)<br />
ba1.Add(Convert.ToByte(hexa, 16));<br />
byte[] ba2 = (byte[])ba1.ToArray(typeof(byte));<br />
|
|
|
|
|
This does not do what it says on the tin, i.e. convert a string into a byte[]. This generates a sequence of bytes, converts them to a string, splits them into a string[] and then individually converts them. This would be useful if and only if you are passing in a string of the format FF-FF-...-FF (imagine that ba_as_string is an argument rather than generated inside the method and ba2 is returned from the method). The vast majority of cases will use the format FFFF...FF or 0xFFFF...FF.
However, after some testing I have found that Convert.ToByte is significantly faster than byte.Parse so I have modified my previous post to use this method. This allows my method to accept FFFF...FF format and, of course, if it is 0xFFFF...FF format, you can just cut off the 0x as you pass the hex string into the method. This cut execution time on 1 million iterations of a 116 character string from an average of 8.237 seconds to an average of 4.961 seconds on my machine, which is approximately 65% faster.
|
|
|
|
|
Hi,
I don't know if I totally agree with you on the format argument... probably it would be more frequent to see stuff like 0xFF-0xFF... and so forth...
No matter, we are discussing small potatoes here, the point was that this is not really a *big* problem and there are several ways to, so to say, "kill the rabbit"...
For example, the following reduces the "for" cycle by half:
string ba_as_string_canonical = ba_as_string.Replace("-", string.Empty);
byte[] ba3 = new byte[ba_as_string_canonical.Length / 2];
for (int i = 0; i < ba_as_string_canonical.Length; i+=2 )
ba3[i/2] = Convert.ToByte(ba_as_string_canonical.Substring(i, 2), 16);
Thanks!
|
|
|
|
|
I have never seen it stored in the format FF-FF or 0xFF-0xFF as this is just a waste of space. For example most databases will represent their blobs as 0xFFFF when human readability is desired, text (hex, rather than base64 obviously) representation of things like hashes is always in the format 0xFFFF or just FFFF, etc. An example of this is the format of an MD5sum file such as this one.
It is standard for the number of characters to be twice the number of bytes but my snippet also pads the first or last byte with a 0 if this is not the case, for example "fff" can be padded to "0fff" or "ff0f" and then treated normally. (The endianness of the data specifies whether "fff" should be treated as 15,255 or 255,15 but you cannot tell this just from the string)
My snippet also already uses the same number of iterations in the for loop as the snippet you have just posted. It just creates a byte array half the length of the string and loops for each of those bytes incrementing by 1, multiplying by 2 to get the string offset rather than dividing by 2 to get the index offset and incrementing by 2. Essentially I am doing "for each byte in the destination array" and you are doing "for each pair of characters in the source string" . In days of old, this would have been a better way of doing it (* rather than /, ++ rather than += 2 etc) but I suspect that modern compilers and modern machines mean that the difference in performance is negligible, particularly on a managed environment. Regardless, I think that it is slightly more readable and any performance benefit that doesn't reduce readability is always a bonus.
As you have shown, you can pass a string in the format FF-FF or even 0xFF-0xFF into my method anyway simply by replacing the - or "0x" with String.Empty. The only problem with this is that F-FF should clearly be treated as 0FFF while FF-F should clearly be treated as FF0F, so any implied endianness is lost when the -s are removed. Obviously not a problem if it is FF-0F in the first place. Ideally, if you know in advance that the string is in the format FF-FF, your code that splits on '-' is better. In all other cases, it is not usable.
The point really is that there are many ways of doing this that are better than the code in the article.
|
|
|
|
|
all version are good.
THE END
|
|
|
|
|
The argument range is limited by Int32.MaxValue and Int32.MinValue. "fae0b7abcd" will throw an OverflowException.
|
|
|
|
|
I needed this so that I could easily convert Hex into a Byte Array. Once converted to a byte array I sent the byte packet out of a serial port to control my Pan Tilt Zoom camera pod. This class made that conversion very very simple to do.
|
|
|
|
|
using System;
using System.Collections.Generic;
using System.Text;
namespace Utilities
{
public class MyHexConverter
{
/// <summary>
/// Helper array to speedup conversion
/// </summary>
static string[] BATHS = { "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" };
static byte[] HSTB = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15 };
/// <summary>
/// Function converts byte array to it's hexadecimal implementation
/// </summary>
/// <param name="ArrayToConvert">Array to be converted</param>
/// <param name="Delimiter">Delimiter to be inserted between bytes</param>
/// <returns>String to represent given array</returns>
public static string ByteArrayToHexString(byte[] ArrayToConvert, string Delimiter)
{
int LengthRequired = ArrayToConvert.Length << 1 + Delimiter.Length * ArrayToConvert.Length + 1;
StringBuilder tempstr = new StringBuilder(LengthRequired, LengthRequired);
foreach (byte CurrentElem in ArrayToConvert)
{
tempstr.Append(BATHS[CurrentElem]);
tempstr.Append(Delimiter);
}
tempstr.Remove(tempstr.Length - 1, 1);
return tempstr.ToString();
}
/// <summary>
/// Function converts given hexadecimal string to it's binary representation
/// </summary>
/// <param name="StringToConvert">String to convert to byte array</param>
/// <returns>Byte array representing given string</returns>
public static byte[] PureHexStringToByteArray(string StringToConvert)
{
byte[] temparr = new byte[StringToConvert.Length / 2];
byte Char1, Char2;
for (int i = 0; i < StringToConvert.Length; i = i + 2)
{
Char1 = (Byte)StringToConvert[i];
Char2 = (Byte)StringToConvert[i + 1];
temparr[i / 2] = (Byte)((HSTB[(Char1 - 48)] << 4) + HSTB[(Char2 - 48)]);
}
return temparr;
}
}
}
|
|
|
|
|
static string[] BATHS = { "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" };
public static string ByteArrayToHexString(byte[] ArrayToConvert, char Delimiter)
{
char[] list = new char[ArrayToConvert.Length * 3];
for (int k = 0; k < ArrayToConvert.Length; ++k)
{
list[k * 3 + 0] = BATHS[ArrayToConvert[k]][0];
list[k * 3 + 1] = BATHS[ArrayToConvert[k]][1];
list[k * 3 + 2] = Delimiter;
}
return new string(list);
}
|
|
|
|
|