是否可以将字符串转换为二进制表示的字节数组

Question

I need to convert an integer which in the form of string to byte array in binary representation. For example : I have a value "29" , then convert this value to binary equivalent 2-> 0010 and 9-> 1001 and store it in byte array where 0th index has 0010 and 1st index has 1001 . I have tried this but this gives me an array of 8 bytes.

var val = "29".ToCharArray();
var a = Convert.ToString(Convert.ToInt32(Convert.ToString(val[0])), 2).PadLeft(4, '0');
var b = Convert.ToString(Convert.ToInt32(Convert.ToString(val[1])), 2).PadLeft(4, '0');

var c = a.ToList();
c.ForEach(x => sb.Append(Convert.ToString(x) + " "));
var f = sb.ToString().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var g = f.ToList();
byte[] buff = new byte[g.Count];
for (int z = 0; z < g.Count; z++)
{
    buff[z] = (byte)Convert.ToInt32(g[z]);
}

var h = b.ToList();
sb.Clear();
h.ForEach(x => sb.Append(Convert.ToString(x) + " "));
var i = sb.ToString().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var j = i.ToList();
byte[] buff2 = new byte[j.Count];
for (int k = 0; k < j.Count; k++)
{
    buff2[k] = (byte)Convert.ToInt32(j[k]);
}
byte[] buffer = buff.Concat(buff2).ToArray();

Answer 1

You can do this much easier:

string s = "29";
var buffer = new byte[s.Length];
for (int i = 0; i < buffer.Length; i++) {
    buffer[i] = (byte)(s[i] - '0');
}

Explanation:

• We create a byte buffer with the same length as the input string since every character in the string is supposed to be a decimal digit.
• In C#, a character is a numeric type. We subtract the character '0' from the character representing our digit to get its numeric value. We get this digit by using the String indexer which allows us to access single characters in a string.
• The result is an integer that we cast to byte we can then insert into the buffer.

Console.WriteLine(buffer[0]) prints 2 because numbers are converted to a string in a decimal format for display. Everything the debugger, the console or a textbox displays is always a string the data has been converted to. This conversion is called formatting. Therefore, you do not see the result as binary. But believe me, it is stored in the bytes in the requested binary format.

You can use Convert.ToString and specify the desired numeric base as second parameter to see the result in binary.

foreach (byte b in buffer) {
    Console.WriteLine($"{b} --> {Convert.ToString(b, toBase: 2).PadLeft(4, '0')}");
}

---

If you want to store it in this visual binary format, then you must store it in a string array

var stringBuffer = new string[s.Length];
for (int i = 0; i < stringBuffer.Length; i++) {
    stringBuffer[i] = Convert.ToString(s[i] - '0', toBase: 2).PadLeft(4, '0');
}

---

Note that everything is stored in a binary format with 0s and 1s in a computer, but you never see these 0s and 1s directly. What you see is always an image on your screen. And this image was created from images of characters in a specific font. And these characters result from converting some data into a string, ie, from formatting your data. The same data might look different on PCs using a different culture, but the underlying data is stored with the same pattern of 0s and 1s.

The difference between storing the numeric value of the digit as byte and storing this digit as character (possibly being an element of a string) is that a different encoding is used.

• The byte stores it as a binary number equivalent to the decimal number. Ie, 9 (decimal) becomes 00001001 (binary).
• The string or character stores the digit using the UTF-16 character table in .NET. This table is equivalent to the ASCII table for Latin letters without accents or umlauts, for digits and for the most common punctuation, except that it uses 16 bits per character instead of 7 bits (expanded to 8 when stored as byte). According to this table, the character '9' is represented by the binary 00111001 (decimal 57).

The string "1001" is stored in UTF-16 as

00000000 00110001  00000000 00110000  00000000 00110000  00000000 00110001

where 0 is encoded as 00000000 00110000 (decimal 48) and 1 is encoded as 00000000 00110001 (decimal 49). Also, additional data is stored for a string, as its length, a NUL character terminator and data related to its class nature.

---

Alternative ways to store the result would be to use an array of the BitArray Class or to use an array of array of bytes where each byte in the inner array would store one bit only, ie, be either 0 or 1.