How do I convert a string to a byte[] in .NET (C#) without manually specifying a specific encoding?
I'm going to encrypt the string. I can encrypt it without converting, but I'd still like to know why encoding comes to play here.
Also, why should encoding even be taken into consideration? Can't I simply get what bytes the string has been stored in? Why is there a dependency on character encodings?
Contrary to the answers here, you DON'T need to worry about encoding if the bytes don't need to be interpreted!
Like you mentioned, your goal is, simply, to "get what bytes the string has been stored in".
(And, of course, to be able to re-construct the string from the bytes.)
For those goals, I honestly do not understand why people keep telling you that you need the encodings. You certainly do NOT need to worry about encodings for this.
Just do this instead:
static byte[] GetBytes(string str)
{
byte[] bytes = new byte[str.Length * sizeof(char)];
System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
return bytes;
}
// Do NOT use on arbitrary bytes; only use on GetBytes's output on the SAME system
static string GetString(byte[] bytes)
{
char[] chars = new char[bytes.Length / sizeof(char)];
System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
return new string(chars);
}
As long as your program (or other programs) don't try to interpret the bytes somehow, which you obviously didn't mention you intend to do, then there is nothing wrong with this approach! Worrying about encodings just makes your life more complicated for no real reason.
Additional benefit to this approach: It doesn't matter if the string contains invalid characters, because you can still get the data and reconstruct the original string anyway!
It will be encoded and decoded just the same, because you are just looking at the bytes.
If you used a specific encoding, though, it would've given you trouble with encoding/decoding invalid characters.
GetBytes back to the same string, it may only use GetString to do this. As long as you don't violate that, you can ignore the concept of encodings entirely. –
Africah ToCharArray() allocates a new array, which gets subsequently discarded? –
Africah GetString and GetBytes need to executed on a system with the same endianness to work. So you can't use this to get bytes you want to turn into a string elsewhere. So I have a hard time to come up with a situations where I'd want to use this. –
Fiedler Encoding.Unicode just because they do the same thing, then it seems like you're not understanding the abstraction layers correctly. –
Africah GetBytes() method will return a Unicode encoded byte array of a string and your GetString() method will (if you pass a Unicode encoded byte array representation of a string) return a readable string and in any other encoding return garbage. Worse than that though GetString() will crash if you pass it a UTF-8 encoded byte array of a string that contains an odd number of characters. –
Dossal GetBytes never happens to return UTF-8 data. It seems like the abstraction layer you're expecting is different from the one that's actually there. If you're not sure how to use it correctly then don't; the answer probably wasn't intended for your use case. However, I 100% stand by my answer that it is correct for the use it was intended, which I tried to make perfectly clear. –
Africah GetBytes and GetString are re-implementations of Encoding.Unicode.GetBytes()\GetString(). You are reframing your argument to side step your initial assertion of "any encoding whatsoever". I'm not disputing the code you've provided the OP wont work (for unicode at least) I just dont think it furthers his understanding of Encoding which he IS using however you try and hide it. –
Dossal Encoding.Unicode. You don't need to worry about encoding either if you simply use those methods, but they are safe no matter what platform you run them on. –
Admission Encoding.Unicode would be slower, with no benefit for the use cases this was intended for (which the OP has understood). Furthermore safety is only a a problem if you don't know what you're doing. You don't see C programmers avoiding pointers, despite of how "dangerous" they are, do you? You also don't see construction workers avoiding electric saws and drills. Just because you think something is dangerous doesn't mean people don't have a right to know about it. –
Africah string in .NET is akin to asking for the bytes of a object. The purpose of the string and char types is that the implementation details are abstracted. By using this answer, you are haphazardly circumventing implementation details and will be left with a fragile solution similar to binary serialization. There is no reason to use this answer, since using encoding is more robust, more portable, more logical, and most importantly easier. Seriously, the Encoding answers are one-liners... why do something crazy like this?! –
Marcum object: .NET specifically prevents you from doing that, but doesn't prevent you from doing this. That by itself should be enough to tell you there's a difference. –
Africah System.Text.Encoding.Unicode.GetBytes(str) because that's what .NET is doing to represent the string in memory. People are saying you don't understand Encoding because they know you can't avoid it. The only thing you're doing is jumping through hoops to hide it! Do you honestly still think this is a good idea? –
Marcum object). There's nothing similar between the two. What I'm telling you is that this code is meant for a different abstraction level than you think. Saying "it's just like Encoding.Unicode.GetBytes" is wrong since it breaks that abstraction barrier. I don't know what else to tell you. My answer already served its purpose, which was to directly answer the OP's question. If you don't like my answer then downvote it; that's what it's for! –
Africah char sequences that can't be represented correctly. –
Africah char sequences in the process, mine doesn't. Keep your downvote, but please think twice before hopping on the bandwagon and spreading misinformation. –
Africah How do I convert a string to a byte array in .NET (C#)? is the OP's described use case. Literally any answer that returns a byte[] would be technically correct. But I'm done with this extended chat. –
Thadeus str.ToCharArray() must rely on an encoding, even if that encoding is not explicitly mentioned in the code (which can only be considered bad). I respect you a lot, Mehrdad, but this is a terrible answer. –
Rone var input = "тхис ис а тест"; var ms = new MemoryStream(GetBytes(input)); var sr = new StreamReader(ms); var output = sr.ReadToEnd(); output is B5AB –
Snead GetBytes to convert a string to bytes, but you're not using GetString to go the reverse direction! These are supposed to be used in pairs; you can't just do whatever you feel like and expect it to work. If you don't use encodings one way you also have to ignore them in the reverse direction, but you ignored the fact that StreamReader is encoding-based! Read my comment earlier: #473406 –
Africah new StreamReader(stream).ReadToEnd() to go in one direction, but using Encoding.UTF8 to go in the other direction. It's wrong because the writer was careless, and it has nothing to do with the answer that might have told you to use UTF8. If the fact that StreamReader uses UTF-16 by default is confusing, don't blame it on my answer; it's not my fault it was designed that way. –
Africah goto statement when better alternatives are available because "well it works in this case doesn't it?". This site is meant for answers that will function properly for as many usecases as possible within the scope of the question. You announcing "YOU DONT NEED ENCODING" in a big size at the top of your answer while leaving the main caveat as a little side note at the bottom could lead to problems. –
Sidky str.SelectMany(BitConvertor.GetBytes).ToArray(); suffice. (yes, I suspect BlockCopy is faster.) –
Villosity sizeof(char) with 2. –
Africah GetString and GetBytes are called on machines with different endianness. But saying "you DON'T need to worry about encoding!" is so terrifyingly evil, since you encourage people to ignore The Absolute Minimum Every Software Developer Absolutely, Positively Must Know. @Lobbyism is right: The encoding IS relevant. –
Alaric bytes.Length in the first place? If you followed the answer correctly (which implies you're using GetBytes to get the bytes) then that event is impossible. If you got the byte array some other way then you have to convert it back to a string the same way instead of using this answer. –
Africah Byte[] and converting that to a string which can later be converted back to Byte[]? I would think byte conversion would allow various "linear" operations (e.g. concatenating two strings produced by the conversion would be equivalent to converting the concatenation of the two arrays), while most other encodings would not. The only disadvantage I see with "straight" conversion is that the lexiographic ordering of the String object would differ from that of the byte[] [fixing that would require byte-swapping pairs]. –
Julijulia String instances which might hold arbitrary binary data, as opposed to those which are known to hold valid UTF-16 strings. It's really too bad MS didn't include any other "immutable blob" types, since String gets used oftentimes when some other standard blob type would probably be more appropriate if any existed. –
Julijulia String.CompareOrdinal on strings produced by converting the KeyData from a SortKey in such fashion will be faster than SortKey.Compare, but producing such strings is a little slow. –
Julijulia fixed (char* p = str) { ... } (2) The reality is that this fact is actually 100% irrelevant because ToCharArray always returns a char array regardless of the underlying data format, which is all we need and care about. –
Africah ToCharArray, the implementation of string storage is irrelevant, of course (except for efficiency...). –
Cinch byte[] before salting and hashing them. In this use case, I absolutely do not care about encoding at all. I don't even need to convert the resulting hash back to a string - for password validation I just directly compare the resulting hash byte[]s. Very elegant and low-overhead solution for this particular use case. The flame war here is a fun read, though. –
Alleenallegation sizeof(char) == 2 byteArray.Length == 9 Then, (byteArray.Length / sizeof(char)) == 4, The call to BlockCopy throws an Exception because you are going out of bounds. I would rather use up a bit more space and go for the easy solution of using Base64 Encoding from the System.Convert class. –
Floridafloridia byte[] ever be an odd number when the GetString method is used the way it is intended here? Also keep in mind that this is just example code. In my not so uncommon use case that I described in my comment before (password hashing), converting back from byte[] to string isn't even necessary. –
Alleenallegation sizeof(char) isn't 1, it's 2. This is C#, not C. –
Africah string even allows that, then that's an entirely different question, and not something I can or will attempt to answer here. I'm just trying to provide an answer that doesn't depend on the string's encoding (if any). –
Africah "\uD800" + "\uDC00" both of these strings are invalid but their concatenation is valid. Maybe you want to convert each one to bytes, transmit them, and convert them back and then concatenate. Maybe they were generated by similarly splitting up a valid string. There's a million ways you could end up with invalid strings... –
Africah System.Text.Encoding.Unicode.GetBytes(); is doing some kind of expensive conversion that he wants to avoid. Unfortunately, what you propose here is less efficient due to the double copy. Also, Endianness is important. OP wants to encrypt the string. It's likely that he doesn't do that to keep the encrypted stryng in memory. It will be written to disk or transferred across the network. What if it is to be decrypted on a machine with different endianness, now or in the future? –
Rabbit char* to a byte* would be the most direct answer, not copying the string twice. –
Rabbit length * sizeof(char) won't give you the size of the text in bytes? There are encodings like UTF-8 where the size of a character can vary. In case of UTF-8 it can be anything from 1 byte to four. –
Chirlin string.Equals("\u0041\u030A", "\u00C5", StringComparison.InvariantCulture) is one example, but it also has absolutely nothing to do with my answer, since you would have exactly the same problem if you specify an encoding. –
Africah GetString does not work for arbitrary byte arrays but only for those produced by GetBytes. I think this also implies either (a) removing the statement "you DON'T need to worry about encoding if the bytes don't need to be interpreted" because the use of GetString implies interpretation (since only "meaningful" byte arrays work as input) or (b) removing GetString itself (which technically isn't necessary for OP). Thoughts? –
Shutout GetString would make GetBytes pointless since you need to be able to reconstruct the original string. I never suggested GetBytes works on "any string" either, that's something else that you read into my comments out of nowhere. If you simply try it it will clearly fail half the time. I was explaining how to get bytes from a string. Re: the note, I didn't add it in the first place; people argued & nitpicked & flamed me for >3 years until someone else added it. I'm sick of arguing over random nitpicking at this point. –
Africah str.ToCharArray() actually uses an hidden "encoding" to convert the 16-bit codeunits to arrays of Char; if it's not lossy, it will push at least two chars per codeunit in the string; if it was lossy, it will drop the highbyte of each code unit to return one Char. Then this depends on the bitsize of each "Char" (which is not necessarily an 8-bit "byte"). Look for the difference between "byte" and "char" data types, they're not equivalent in C# (same thing in C and C++). To allow lossless conversions with strings without exceptions, a "char" needs to be an unsigned 16-bit exactly. –
Stratiform str.Length * sizeof(char) is the size of the string? I mean the string doesn't even have to be English characters. For example, in UTF-8 "你好", which returns length as 2, but each of them is 3 bytes instead of 1 byte in UTF-8! –
Chiaroscuro str;Length * sizeof(char) is somewhat wrong, it would be slightly better to fetch Length from the GetCharArray() result. That chararray.Length * sizeof(char) really is exactly the size of the char array (content, not counting .NET vtable, synchronization, and garbage collector bookkeeping overhead), and a .NET string is a char array, so it also is the "size" of the string (content). –
Rite It depends on the encoding of your string (ASCII, UTF-8, ...).
For example:
byte[] b1 = System.Text.Encoding.UTF8.GetBytes (myString);
byte[] b2 = System.Text.Encoding.ASCII.GetBytes (myString);
A small sample why encoding matters:
string pi = "\u03a0";
byte[] ascii = System.Text.Encoding.ASCII.GetBytes (pi);
byte[] utf8 = System.Text.Encoding.UTF8.GetBytes (pi);
Console.WriteLine (ascii.Length); //Will print 1
Console.WriteLine (utf8.Length); //Will print 2
Console.WriteLine (System.Text.Encoding.ASCII.GetString (ascii)); //Will print '?'
ASCII simply isn't equipped to deal with special characters.
Internally, the .NET framework uses UTF-16 to represent strings, so if you simply want to get the exact bytes that .NET uses, use System.Text.Encoding.Unicode.GetBytes (...).
See Character Encoding in the .NET Framework (MSDN) for more information.
GetString method is and interpretation of the output of the GetBytes method. This is why you have to worry to use the same encoding in both methods. –
Admission String object in the first place in .NET? And what would be the point of encoding a string to bytes if you don't then intend to interpret it in some way (like decoding it back to a string)? –
Pyrene String object; it will treat your files as a sequence of bytes from start to finish. There's a fundamental conceptual mismatch between "I have data as a String" and "I need to treat the data as arbitrary bytes." Something must have decoded the data to a String to begin with, using a particular text encoding, which might not be .NET's internal encoding (so reading the bytes without encoding them could corrupt the data). Somewhere in that contradiction is the fact you're using the wrong tool for the job to begin with. –
Pyrene memcpy your wchar_t[], tell your LZMA library to compress it as a generic blob without providing encoding info, and later decompress it & reconstruct the original. End of story. The only difference is we have C# here. –
Africah String. There's no way around this: you either don't need to use a String, or you need to use a consistent encoding to go from String to bytes and back. One of those must be the case. –
Pyrene memcpy would do in C. Have you ever programmed in C? –
Africah fixed (char* p = str) and Java hasn't. That already locked them into the decision of how to represent strings. –
Africah The accepted answer is very, very complicated. Use the included .NET classes for this:
const string data = "A string with international characters: Norwegian: ÆØÅæøå, Chinese: 喂 谢谢";
var bytes = System.Text.Encoding.UTF8.GetBytes(data);
var decoded = System.Text.Encoding.UTF8.GetString(bytes);
Don't reinvent the wheel if you don't have to...
System.Text.Encoding.Unicode to be equivalent to Mehrdad's answer. –
Villosity System.Text.Encoding.Unicode.GetBytes would probably be more precise. –
Cinch Encoding.Default.GetBytes. –
Fire Encoding.Default.GetBytes results are the same as those applications. I am not providing an answer to the OP question. –
Fire BinaryFormatter bf = new BinaryFormatter();
byte[] bytes;
MemoryStream ms = new MemoryStream();
string orig = "喂 Hello 谢谢 Thank You";
bf.Serialize(ms, orig);
ms.Seek(0, 0);
bytes = ms.ToArray();
MessageBox.Show("Original bytes Length: " + bytes.Length.ToString());
MessageBox.Show("Original string Length: " + orig.Length.ToString());
for (int i = 0; i < bytes.Length; ++i) bytes[i] ^= 168; // pseudo encrypt
for (int i = 0; i < bytes.Length; ++i) bytes[i] ^= 168; // pseudo decrypt
BinaryFormatter bfx = new BinaryFormatter();
MemoryStream msx = new MemoryStream();
msx.Write(bytes, 0, bytes.Length);
msx.Seek(0, 0);
string sx = (string)bfx.Deserialize(msx);
MessageBox.Show("Still intact :" + sx);
MessageBox.Show("Deserialize string Length(still intact): "
+ sx.Length.ToString());
BinaryFormatter bfy = new BinaryFormatter();
MemoryStream msy = new MemoryStream();
bfy.Serialize(msy, sx);
msy.Seek(0, 0);
byte[] bytesy = msy.ToArray();
MessageBox.Show("Deserialize bytes Length(still intact): "
+ bytesy.Length.ToString());
This is a popular question. It is important to understand what the question author is asking, and that it is different from what is likely the most common need. To discourage misuse of the code where it is not needed, I've answered the latter first.
Every string has a character set and encoding. When you convert a System.String object to an array of System.Byte you still have a character set and encoding. For most usages, you'd know which character set and encoding you need and .NET makes it simple to "copy with conversion." Just choose the appropriate Encoding class.
// using System.Text;
Encoding.UTF8.GetBytes(".NET String to byte array")
The conversion may need to handle cases where the target character set or encoding doesn't support a character that's in the source. You have some choices: exception, substitution, or skipping. The default policy is to substitute a '?'.
// using System.Text;
var text = Encoding.ASCII.GetString(Encoding.ASCII.GetBytes("You win €100"));
// -> "You win ?100"
Clearly, conversions are not necessarily lossless!
Note: For System.String the source character set is Unicode.
The only confusing thing is that .NET uses the name of a character set for the name of one particular encoding of that character set. Encoding.Unicode should be called Encoding.UTF16.
That's it for most usages. If that's what you need, stop reading here. See the fun Joel Spolsky article if you don't understand what encoding is.
Now, the question author asks is, "Every string is stored as an array of bytes, right? Why can't I simply have those bytes?"
He doesn't want any conversion.
From the C# spec:
Character and string processing in C# uses Unicode encoding. The char type represents a UTF-16 code unit, and the string type represents a sequence of UTF-16 code units.
So, we know that if we ask for the null conversion (i.e., from UTF-16 to UTF-16), we'll get the desired result:
Encoding.Unicode.GetBytes(".NET String to byte array")
But to avoid the mention of encodings, we must do it another way. If an intermediate data type is acceptable, there is a conceptual shortcut for this:
".NET String to byte array".ToCharArray()
That doesn't get us the desired datatype but Mehrdad's answer shows how to convert this Char array to a Byte array using BlockCopy. However, this copies the string twice! And, it too explicitly uses encoding-specific code: the datatype System.Char.
The only way to get to the actual bytes the String is stored in is to use a pointer. The fixed statement allows taking the address of values. From the C# spec:
[For] an expression of type string, ... the initializer computes the address of the first character in the string.
To do so, the compiler writes code skipping over the other parts of the string object with RuntimeHelpers.OffsetToStringData. So, to get the raw bytes, just create a pointer to the string and copy the number of bytes needed.
// using System.Runtime.InteropServices
unsafe byte[] GetRawBytes(String s)
{
if (s == null) return null;
var codeunitCount = s.Length;
/* We know that String is a sequence of UTF-16 code units
and such code units are 2 bytes */
var byteCount = codeunitCount * 2;
var bytes = new byte[byteCount];
fixed(void* pRaw = s)
{
Marshal.Copy((IntPtr)pRaw, bytes, 0, byteCount);
}
return bytes;
}
As @CodesInChaos pointed out, the result depends on the endianness of the machine. But the question author is not concerned with that.
byteCount to twice the string length. For Unicode code points outside the Basic Multilingual Plane, there will be two 16-bit code units for each character. –
Arrivederci Length property [of String] returns the number of Char objects in this instance, not the number of Unicode characters." Your example code is therefore correct as written. –
Arrivederci Char is really an "encoding-specific" type; from what I can tell, there is a specified 1:1 relationship between Char values and UInt16 values, any Char[] can be converted to a string of the same length, and any such string may be converted to a Char[] equal to the original, whether or not the sequence of Char values ever formed a valid UTF-16 string. –
Julijulia new String(new []{'\uD800', '\u0030'}) –
Burmese String that better encapsulates the concept of "immutable sequence of 16-bit values"; because System.String has special Runtime support which is not available for any other type, it can offer better performance for many operations than would be possible with any other type. –
Julijulia Globalization.SortKey, extracts the KeyData, and packs the resulting bytes from each into a String [two bytes per character, MSB first], calling String.CompareOrdinal upon the resulting strings will be substantially faster than calling SortKey.Compare on the instances of SortKey, or even calling memcmp on those instances. Given that, I wonder why KeyData returns a Byte[] rather than a String? –
Julijulia unsafe string GetString(byte[] bytes) { fixed (byte* bptr = bytes) { char* cptr = (char*)(bptr); var result = new string(cptr, 0, bytes.Length / 2); return result; } } –
Toneytong codeunitcount * 2 is the correct number of bytes for a code unit. The code does not count codepoints at all. –
Burmese fixed or unsafe code, you can also do var gch = GCHandle.Alloc("foo", GCHandleType.Pinned); var arr = new byte[sizeof(char) * ((string)gch.Target).Length]; Marshal.Copy(gch.AddrOfPinnedObject(), arr, 0, arr.Length); gch.Free(); –
Africah You need to take the encoding into account, because 1 character could be represented by 1 or more bytes (up to about 6), and different encodings will treat these bytes differently.
Joel has a posting on this:
The first part of your question (how to get the bytes) was already answered by others: look in the System.Text.Encoding namespace.
I will address your follow-up question: why do you need to pick an encoding? Why can't you get that from the string class itself?
The answer is in two parts.
First of all, the bytes used internally by the string class don't matter, and whenever you assume they do you're likely introducing a bug.
If your program is entirely within the .Net world then you don't need to worry about getting byte arrays for strings at all, even if you're sending data across a network. Instead, use .Net Serialization to worry about transmitting the data. You don't worry about the actual bytes anymore: the Serialization formatter does it for you.
On the other hand, what if you are sending these bytes somewhere that you can't guarantee will pull in data from a .Net serialized stream? In this case, you definitely do need to worry about encoding, because obviously, this external system cares. So again, the internal bytes used by the string don't matter: you need to pick an encoding so you can be explicit about this encoding on the receiving end, even if it's the same encoding used internally by .Net.
I understand that in this case, you might prefer to use the actual bytes stored by the string variable in memory where possible, with the idea that it might save some work creating your byte stream. However, I put it to you it's just not important compared to making sure that your output is understood at the other end, and to guarantee that you must be explicit with your encoding. Additionally, if you really want to match your internal bytes, you can already just choose the Unicode encoding, and get those performance savings.
This brings me to the second part... picking the Unicode encoding is telling .Net to use the underlying bytes. You do need to pick this encoding because when some new-fangled Unicode-Plus comes out the .Net runtime needs to be free to use this newer, better encoding model without breaking your program. But, for the moment (and foreseeable future), just choosing the Unicode encoding gives you what you want.
It's also important to understand your string has to be rewritten to wire, and that involves at least some translation of the bit-pattern even when you use a matching encoding. The computer needs to account for things like Big vs Little Endian, network byte order, packetization, session information, etc.
Just to demonstrate that Mehrdrad's sound answer works, his approach can even persist the unpaired surrogate characters(of which many had leveled against my answer, but of which everyone are equally guilty of, e.g. System.Text.Encoding.UTF8.GetBytes, System.Text.Encoding.Unicode.GetBytes; those encoding methods can't persist the high surrogate characters d800 for example, and those just merely replace high surrogate characters with value fffd ) :
using System;
class Program
{
static void Main(string[] args)
{
string t = "爱虫";
string s = "Test\ud800Test";
byte[] dumpToBytes = GetBytes(s);
string getItBack = GetString(dumpToBytes);
foreach (char item in getItBack)
{
Console.WriteLine("{0} {1}", item, ((ushort)item).ToString("x"));
}
}
static byte[] GetBytes(string str)
{
byte[] bytes = new byte[str.Length * sizeof(char)];
System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
return bytes;
}
static string GetString(byte[] bytes)
{
char[] chars = new char[bytes.Length / sizeof(char)];
System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
return new string(chars);
}
}
Output:
T 54
e 65
s 73
t 74
? d800
T 54
e 65
s 73
t 74
Try that with System.Text.Encoding.UTF8.GetBytes or System.Text.Encoding.Unicode.GetBytes, they will merely replace high surrogate characters with value fffd
Every time there's a movement in this question, I'm still thinking of a serializer(be it from Microsoft or from 3rd party component) that can persist strings even it contains unpaired surrogate characters; I google this every now and then: serialization unpaired surrogate character .NET. This doesn't make me lose any sleep, but it's kind of annoying when every now and then there's somebody commenting on my answer that it's flawed, yet their answers are equally flawed when it comes to unpaired surrogate characters.
Darn, Microsoft should have just used System.Buffer.BlockCopy in its BinaryFormatter ツ
谢谢！
System.Buffer.BlockCopy internally, all encoding-advocacy folks' arguments will be moot –
Floorboard FFFD on that character. If you want to do manual string manipulation, use a char[] as recommended. –
Penniepenniless String.CompareOrdinal be usable without "unsafe" code? Converting Char[] arrays with unmatched surrogates to String for purposes of using String.CompareOrdinal on them is nasty, but what approach would be better? –
Julijulia System.String is an immutable sequence of Char; .NET has always allowed a String object to be constructed from any Char[] and export its content to a Char[] containing the same values, even if the original Char[] contains unpaired surrogates. –
Julijulia char". If you read the C# language specification, it says "the char type represents a UTF-16 code unit, and the string type represents a sequence of UTF-16 code units". Note that it does not say string has to be a well-formed "Unicode string" (and note that even "Unicode String" is explicitly permitted to be ill-formed in the glossary). –
Africah strings). –
Africah Try this, a lot less code:
System.Text.Encoding.UTF8.GetBytes("TEST String");
System.Text.Encoding.UTF8.GetBytes("Árvíztűrő tükörfúrógép);, and cry! It will work, but System.Text.Encoding.UTF8.GetBytes("Árvíztűrő tükörfúrógép").Length != System.Text.Encoding.UTF8.GetBytes("Arvizturo tukorfurogep").Length while "Árvíztűrő tükörfúrógép".Length == "Arvizturo tukorfurogep".Length –
Chirlin Well, I've read all answers and they were about using encoding or one about serialization that drops unpaired surrogates.
It's bad when the string, for example, comes from SQL Server where it was built from a byte array storing, for example, a password hash. If we drop anything from it, it'll store an invalid hash, and if we want to store it in XML, we want to leave it intact (because the XML writer drops an exception on any unpaired surrogate it finds).
So I use Base64 encoding of byte arrays in such cases, but hey, on the Internet there is only one solution to this in C#, and it has bug in it and is only one way, so I've fixed the bug and written back procedure. Here you are, future googlers:
public static byte[] StringToBytes(string str)
{
byte[] data = new byte[str.Length * 2];
for (int i = 0; i < str.Length; ++i)
{
char ch = str[i];
data[i * 2] = (byte)(ch & 0xFF);
data[i * 2 + 1] = (byte)((ch & 0xFF00) >> 8);
}
return data;
}
public static string StringFromBytes(byte[] arr)
{
char[] ch = new char[arr.Length / 2];
for (int i = 0; i < ch.Length; ++i)
{
ch[i] = (char)((int)arr[i * 2] + (((int)arr[i * 2 + 1]) << 8));
}
return new String(ch);
}
Convert.ToBase64String(arr); for the base64 conversions byte[] (data) <-> string (serialized data to store in XML file). But to get the initial byte[] (data) I needed to do something with a String that contained binary data (it's the way MSSQL returned it to me). SO the functions above are for String (binary data) <-> byte[] (easy accessible binary data). –
Helicline Also please explain why encoding should be taken into consideration. Can't I simply get what bytes the string has been stored in? Why this dependency on encoding?!!!
Because there is no such thing as "the bytes of the string".
A string (or more generically, a text) is composed of characters: letters, digits, and other symbols. That's all. Computers, however, do not know anything about characters; they can only handle bytes. Therefore, if you want to store or transmit text by using a computer, you need to transform the characters to bytes. How do you do that? Here's where encodings come to the scene.
An encoding is nothing but a convention to translate logical characters to physical bytes. The simplest and best known encoding is ASCII, and it is all you need if you write in English. For other languages you will need more complete encodings, being any of the Unicode flavours the safest choice nowadays.
So, in short, trying to "get the bytes of a string without using encodings" is as impossible as "writing a text without using any language".
By the way, I strongly recommend you (and anyone, for that matter) to read this small piece of wisdom: The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)
C# to convert a string to a byte array:
public static byte[] StrToByteArray(string str)
{
System.Text.UTF8Encoding encoding=new System.Text.UTF8Encoding();
return encoding.GetBytes(str);
}
byte[] strToByteArray(string str)
{
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
return enc.GetBytes(str);
}
You can use the following code for conversion between string and byte array.
string s = "Hello World";
// String to Byte[]
byte[] byte1 = System.Text.Encoding.Default.GetBytes(s);
// OR
byte[] byte2 = System.Text.ASCIIEncoding.Default.GetBytes(s);
// Byte[] to string
string str = System.Text.Encoding.UTF8.GetString(byte1);
With the advent of Span<T> released with C# 7.2, the canonical technique to capture the underlying memory representation of a string into a managed byte array is:
byte[] bytes = "rubbish_\u9999_string".AsSpan().AsBytes().ToArray();
Converting it back should be a non-starter because that means you are in fact interpreting the data somehow, but for the sake of completeness:
string s;
unsafe
{
fixed (char* f = &bytes.AsSpan().NonPortableCast<byte, char>().DangerousGetPinnableReference())
{
s = new string(f);
}
}
The names NonPortableCast and DangerousGetPinnableReference should further the argument that you probably shouldn't be doing this.
Note that working with Span<T> requires installing the System.Memory NuGet package.
Regardless, the actual original question and follow-up comments imply that the underlying memory is not being "interpreted" (which I assume means is not modified or read beyond the need to write it as-is), indicating that some implementation of the Stream class should be used instead of reasoning about the data as strings at all.
new string(f) is wrong, you at least need to use the constructor overload that accepts an explicit length if you want any hope of round-tripping all strings. –
Rite I'm not sure, but I think the string stores its info as an array of Chars, which is inefficient with bytes. Specifically, the definition of a Char is "Represents a Unicode character".
take this example sample:
String str = "asdf éß";
String str2 = "asdf gh";
EncodingInfo[] info = Encoding.GetEncodings();
foreach (EncodingInfo enc in info)
{
System.Console.WriteLine(enc.Name + " - "
+ enc.GetEncoding().GetByteCount(str)
+ enc.GetEncoding().GetByteCount(str2));
}
Take note that the Unicode answer is 14 bytes in both instances, whereas the UTF-8 answer is only 9 bytes for the first, and only 7 for the second.
So if you just want the bytes used by the string, simply use Encoding.Unicode, but it will be inefficient with storage space.
The key issue is that a glyph in a string takes 32 bits (16 bits for a character code) but a byte only has 8 bits to spare. A one-to-one mapping doesn't exist unless you restrict yourself to strings that only contain ASCII characters. System.Text.Encoding has lots of ways to map a string to byte[], you need to pick one that avoids loss of information and that is easy to use by your client when she needs to map the byte[] back to a string.
Utf8 is a popular encoding, it is compact and not lossy.
Use:
string text = "string";
byte[] array = System.Text.Encoding.UTF8.GetBytes(text);
The result is:
[0] = 115
[1] = 116
[2] = 114
[3] = 105
[4] = 110
[5] = 103
Fastest way
public static byte[] GetBytes(string text)
{
return System.Text.ASCIIEncoding.UTF8.GetBytes(text);
}
EDIT as Makotosan commented this is now the best way:
Encoding.UTF8.GetBytes(text)
The closest approach to the OP's question is Tom Blodget's, which actually goes into the object and extracts the bytes. I say closest because it depends on implementation of the String Object.
"Can't I simply get what bytes the string has been stored in?"
Sure, but that's where the fundamental error in the question arises. The String is an object which could have an interesting data structure. We already know it does, because it allows unpaired surrogates to be stored. It might store the length. It might keep a pointer to each of the 'paired' surrogates allowing quick counting. Etc. All of these extra bytes are not part of the character data.
What you want is each character's bytes in an array. And that is where 'encoding' comes in. By default you will get UTF-16LE. If you don't care about the bytes themselves except for the round trip then you can choose any encoding including the 'default', and convert it back later (assuming the same parameters such as what the default encoding was, code points, bug fixes, things allowed such as unpaired surrogates, etc.
But why leave the 'encoding' up to magic? Why not specify the encoding so that you know what bytes you are gonna get?
"Why is there a dependency on character encodings?"
Encoding (in this context) simply means the bytes that represent your string. Not the bytes of the string object. You wanted the bytes the string has been stored in -- this is where the question was asked naively. You wanted the bytes of string in a contiguous array that represent the string, and not all of the other binary data that a string object may contain.
Which means how a string is stored is irrelevant. You want a string "Encoded" into bytes in a byte array.
I like Tom Bloget's answer because he took you towards the 'bytes of the string object' direction. It's implementation dependent though, and because he's peeking at internals it might be difficult to reconstitute a copy of the string.
Mehrdad's response is wrong because it is misleading at the conceptual level. You still have a list of bytes, encoded. His particular solution allows for unpaired surrogates to be preserved -- this is implementation dependent. His particular solution would not produce the string's bytes accurately if GetBytes returned the string in UTF-8 by default.
I've changed my mind about this (Mehrdad's solution) -- this isn't getting the bytes of the string; rather it is getting the bytes of the character array that was created from the string. Regardless of encoding, the char datatype in c# is a fixed size. This allows a consistent length byte array to be produced, and it allows the character array to be reproduced based on the size of the byte array. So if the encoding were UTF-8, but each char was 6 bytes to accommodate the largest utf8 value, it would still work. So indeed -- encoding of the character does not matter.
But a conversion was used -- each character was placed into a fixed size box (c#'s character type). However what that representation is does not matter, which is technically the answer to the OP. So -- if you are going to convert anyway... Why not 'encode'?
& (Char) 55906 & (Char) 55655. So you may be wrong and Mehrdad's answer is a safe conversion without considering what type of encodings are used. –
Zealotry How do I convert a string to a byte[] in .NET (C#) without manually specifying a specific encoding?
A string in .NET represents text as a sequence of UTF-16 code units, so the bytes are encoded in memory in UTF-16 already.
Mehrdad's Answer
You can use Mehrdad's answer, but it does actually use an encoding because chars are UTF-16. It calls ToCharArray which looking at the source creates a char[] and copies the memory to it directly. Then it copies the data to a byte array that is also allocated. So under the hood it is copying the underlying bytes twice and allocating a char array that is not used after the call.
Tom Blodget's Answer
Tom Blodget's answer is 20-30% faster than Mehrdad since it skips the intermediate step of allocating a char array and copying the bytes to it, but it requires you compile with the /unsafe option. If you absolutely do not want to use encoding, I think this is the way to go. If you put your encryption login inside the fixed block, you don't even need to allocate a separate byte array and copy the bytes to it.
Also, why should encoding be taken into consideration? Can't I simply get what bytes the string has been stored in? Why is there a dependency on character encodings?
Because that is the proper way to do it. string is an abstraction.
Using an encoding could give you trouble if you have 'strings' with invalid characters, but that shouldn't happen. If you are getting data into your string with invalid characters you are doing it wrong. You should probably be using a byte array or a Base64 encoding to start with.
If you use System.Text.Encoding.Unicode, your code will be more resilient. You don't have to worry about the endianness of the system your code will be running on. You don't need to worry if the next version of the CLR will use a different internal character encoding.
I think the question isn't why you want to worry about the encoding, but why you want to ignore it and use something else. Encoding is meant to represent the abstraction of a string in a sequence of bytes. System.Text.Encoding.Unicode will give you a little endian byte order encoding and will perform the same on every system, now and in the future.
You can use following code to convert a string to a byte array in .NET
string s_unicode = "abcéabc";
byte[] utf8Bytes = System.Text.Encoding.UTF8.GetBytes(s_unicode);
If you really want a copy of the underlying bytes of a string, you can use a function like the one that follows. However, you shouldn't please read on to find out why.
[DllImport(
"msvcrt.dll",
EntryPoint = "memcpy",
CallingConvention = CallingConvention.Cdecl,
SetLastError = false)]
private static extern unsafe void* UnsafeMemoryCopy(
void* destination,
void* source,
uint count);
public static byte[] GetUnderlyingBytes(string source)
{
var length = source.Length * sizeof(char);
var result = new byte[length];
unsafe
{
fixed (char* firstSourceChar = source)
fixed (byte* firstDestination = result)
{
var firstSource = (byte*)firstSourceChar;
UnsafeMemoryCopy(
firstDestination,
firstSource,
(uint)length);
}
}
return result;
}
This function will get you a copy of the bytes underlying your string, pretty quickly. You'll get those bytes in whatever way they are encoding on your system. This encoding is almost certainly UTF-16LE but that is an implementation detail you shouldn't have to care about.
It would be safer, simpler and more reliable to just call,
System.Text.Encoding.Unicode.GetBytes()
In all likelihood this will give the same result, is easier to type, and the bytes will round-trip, as well as a byte representation in Unicode can, with a call to
System.Text.Encoding.Unicode.GetString()
Unicode.GetBytes() / Unicode.GetString() does NOT round-trip for all .NET string instances. –
Rite Marshal.Copy will work fine for copying from a pointer to a byte array. https://mcmap.net/q/41028/-alternative-to-buffer-memorycopy-pre-net-4-6 –
Rite Here is my unsafe implementation of String to Byte[] conversion:
public static unsafe Byte[] GetBytes(String s)
{
Int32 length = s.Length * sizeof(Char);
Byte[] bytes = new Byte[length];
fixed (Char* pInput = s)
fixed (Byte* pBytes = bytes)
{
Byte* source = (Byte*)pInput;
Byte* destination = pBytes;
if (length >= 16)
{
do
{
*((Int64*)destination) = *((Int64*)source);
*((Int64*)(destination + 8)) = *((Int64*)(source + 8));
source += 16;
destination += 16;
}
while ((length -= 16) >= 16);
}
if (length > 0)
{
if ((length & 8) != 0)
{
*((Int64*)destination) = *((Int64*)source);
source += 8;
destination += 8;
}
if ((length & 4) != 0)
{
*((Int32*)destination) = *((Int32*)source);
source += 4;
destination += 4;
}
if ((length & 2) != 0)
{
*((Int16*)destination) = *((Int16*)source);
source += 2;
destination += 2;
}
if ((length & 1) != 0)
{
++source;
++destination;
destination[0] = source[0];
}
}
}
return bytes;
}
It's way faster than the accepted anwser's one, even if not as elegant as it is. Here are my Stopwatch benchmarks over 10000000 iterations:
[Second String: Length 20]
Buffer.BlockCopy: 746ms
Unsafe: 557ms
[Second String: Length 50]
Buffer.BlockCopy: 861ms
Unsafe: 753ms
[Third String: Length 100]
Buffer.BlockCopy: 1250ms
Unsafe: 1063ms
In order to use it, you have to tick "Allow Unsafe Code" in your project build properties. As per .NET Framework 3.5, this method can also be used as String extension:
public static unsafe class StringExtensions
{
public static Byte[] ToByteArray(this String s)
{
// Method Code
}
}
RuntimeHelpers.OffsetToStringData a multiple of 8 on the Itanium versions of .NET? Because otherwise this will fail due to the unaligned reads. –
Guttersnipe memcpy? https://mcmap.net/q/40530/-how-do-i-get-a-consistent-byte-representation-of-strings-in-c-without-manually-specifying-an-encoding –
Villosity Upon being asked what you intend to do with the bytes, you responded:
I'm going to encrypt it. I can encrypt it without converting but I'd still like to know why encoding comes to play here. Just give me the bytes is what I say.
Regardless of whether you intend to send this encrypted data over the network, load it back into memory later, or stream it to another process, you are clearly intending to decrypt it at some point. In that case, the answer is that you're defining a communication protocol. A communication protocol should not be defined in terms of implementation details of your programming language and its associated runtime. There are several reasons for this:
For communicating (either with a completely disparate process or with the same program in the future), you need to define your protocol strictly to minimize the difficulty of working with it or accidentally creating bugs. Depending on .NET's internal representation is not a strict, clear, or even guaranteed to be consistent definition. A standard encoding is a strict definition that will not fail you in the future.
In other words, you can't satisfy your requirement for consistency without specifying an encoding.
You may certainly choose to use UTF-16 directly if you find that your process performs significantly better since .NET uses it internally or for any other reason, but you need to choose that encoding explicitly and perform those conversions explicitly in your code rather than depending on .NET's internal implementation.
So choose an encoding and use it:
using System.Text;
// ...
Encoding.Unicode.GetBytes("abc"); # UTF-16 little endian
Encoding.UTF8.GetBytes("abc")
As you can see, it's also actually less code to just use the built in encoding objects than to implement your own reader/writer methods.
Computers only understand raw binary data, raw bits. One bit is a Binary Digit : 0 or 1. An 8-bits number is a byte. One byte is a number between 0 and 255.
ASCII is a table that converts numbers to characters. Numbers between 0 and 31 are controls: tab, new line, and others. Numbers between 32 and 126 are printable characters : letter a, number 1, % sign, underscore _
So with ASCII, there are 33 control characters and 95 printable characters.
ASCII is the most commonly used character encoding today. The first entries of the Unicode table are ASCII and match the ASCII character set.
ASCII is a 7-bit character set. Numbers between 0 and 127. With 8 bits we can go up to 255.
The most common alternative to ASCII is EBCDIC which is not compatible with ASCII and still exists today on IBM computers and databases.
1 byte, so 8 bits number is the most common unit in computer science nowadays. 1 byte is a number between 0 and 255.
ASCII defines a meaning for each number between 0 and 127.
The character associated with numbers between 128 and 255 depends on the character encoding being used. Two widely used character encodings used nowadays are windows1252 and UTF-8.
In windows1252 the number corresponding to the € sign is 128. 1 byte : [A0]. In the Unicode Database, the € sign is number 8364.
Now I give you the number 8364. Tow bytes : [20,AC]. In UTF-8 the Euro sign is the number 14844588. Three bytes : [E282AC].
Now I give you some raw data. Let's say 20AC. Is it two windows1252 characters: £ or one single Unicode € sign?
I give you some more raw data. E282AC. Well, 82 is an unassigned character in windows1252 so it is probably not windows1252. It could be macRoman "‚Ǩ" or OEM 437 "ßéó" or the UTF-8 "€" sign.
It is possible to guess the encoding of a stream of raw bytes based on the characteristics of the character encodings and on statistics but there is no reliable way to do that. Numbers between 128 and 255 on their own are invalid in UTF-8. The é is common in some languages (french) so if you see many bytes with the value E9 surrounded by letters it is probably a windows1252-encoding string, the E9 byte representing the é character.
When you have a stream of raw bytes that represents a string, it is far better to know the matching encoding rather than trying to guess.
Below is a screenshot of one raw byte in various encodings that were once widely used.
The string can be converted to byte array in few different ways, due to the following fact: .NET supports Unicode, and Unicode standardizes several difference encodings called UTFs. They have different lengths of byte representation but are equivalent in that sense that when a string is encoded, it can be coded back to the string, but if the string is encoded with one UTF and decoded in the assumption of different UTF if can be screwed up.
Also, .NET supports non-Unicode encodings, but they are not valid in general case (will be valid only if a limited sub-set of Unicode code point is used in an actual string, such as ASCII). Internally, .NET supports UTF-16, but for stream representation, UTF-8 is usually used. It is also a standard-de-facto for Internet.
Not surprisingly, serialization of string into an array of byte and deserialization is supported by the class System.Text.Encoding, which is an abstract class; its derived classes support concrete encodings: ASCIIEncoding and four UTFs (System.Text.UnicodeEncoding supports UTF-16)
Ref this link.
For serialization to an array of bytes using System.Text.Encoding.GetBytes. For the inverse operation use System.Text.Encoding.GetChars. This function returns an array of characters, so to get a string, use a string constructor System.String(char[]).
Ref this page.
Example:
string myString = //... some string
System.Text.Encoding encoding = System.Text.Encoding.UTF8; //or some other, but prefer some UTF is Unicode is used
byte[] bytes = encoding.GetBytes(myString);
//next lines are written in response to a follow-up questions:
myString = new string(encoding.GetChars(bytes));
byte[] bytes = encoding.GetBytes(myString);
myString = new string(encoding.GetChars(bytes));
byte[] bytes = encoding.GetBytes(myString);
//how many times shall I repeat it to show there is a round-trip? :-)
This is because, as Tyler so aptly said, "Strings aren't pure data. They also have information." In this case, the information is an encoding that was assumed when the string was created.
This is based off of OP's comment on his own question, and is the correct question if I understand OP's hints at the use-case.
Storing binary data in strings is probably the wrong approach because of the assumed encoding mentioned above! Whatever program or library stored that binary data in a string (instead of a byte[] array which would have been more appropriate) has already lost the battle before it has begun. If they are sending the bytes to you in a REST request/response or anything that must transmit strings, Base64 would be the right approach.
Everybody else answered this incorrect question incorrectly.
If the string looks good as-is, just pick an encoding (preferably one starting with UTF), use the corresponding System.Text.Encoding.???.GetBytes() function, and tell whoever you give the bytes to which encoding you picked.
If you are using .NET Core or System.Memory for .NET Framework, there is a very efficient marshaling mechanism available via Span<T> and Memory<T> that can effectively reinterpret string memory as a span of bytes. Once you have a span of bytes you are free to marshal back to another type, or copy the span to an array for serialization.
To summarize what others have said:
public static class MarshalExtensions
{
public static ReadOnlySpan<byte> AsBytes(this string value) => MemoryMarshal.AsBytes(value.AsSpan());
public static string AsString(this ReadOnlySpan<byte> value) => new string(MemoryMarshal.Cast<byte, char>(value));
}
static void Main(string[] args)
{
string str1 = "你好，世界";
ReadOnlySpan<byte> span = str1.AsBytes();
string str2 = span.AsString();
byte[] bytes = span.ToArray();
Debug.Assert(bytes.Length > 0);
Debug.Assert(str1 == str2);
}
In C++ this is roughly equivalent to reinterpret_cast, and C this is roughly equivalent to a cast to the system's word type (char).
In recent versions of the .NET Core Runtime (CoreCLR), operations on spans effectively invoke compiler intrinsics and various optimizations that can sometimes eliminate bounds checking, leading to exceptional performance while preserving memory safety, assuming that your memory was allocated by the CLR and the spans are not derived from pointers from an unmanaged memory allocator.
This uses a mechanism supported by the CLR that returns ReadOnlySpan<char> from a string; Additionally, this span does not necessarily encompass the complete internal string layout. ReadOnlySpan<T> implies that you must create a copy if you need to perform mutation, as strings are immutable.
Two ways:
public static byte[] StrToByteArray(this string s)
{
List<byte> value = new List<byte>();
foreach (char c in s.ToCharArray())
value.Add(c.ToByte());
return value.ToArray();
}
And,
public static byte[] StrToByteArray(this string s)
{
s = s.Replace(" ", string.Empty);
byte[] buffer = new byte[s.Length / 2];
for (int i = 0; i < s.Length; i += 2)
buffer[i / 2] = (byte)Convert.ToByte(s.Substring(i, 2), 16);
return buffer;
}
I tend to use the bottom one more often than the top, haven't benchmarked them for speed.
bytes[] buffer = UnicodeEncoding.UTF8.GetBytes(string something); //for converting to UTF then get its bytes
bytes[] buffer = ASCIIEncoding.ASCII.GetBytes(string something); //for converting to ascii then get its bytes
simple code with LINQ
string s = "abc"
byte[] b = s.Select(e => (byte)e).ToArray();
EDIT : as commented below, it is not a good way.
but you can still use it to understand LINQ with a more appropriate coding :
string s = "abc"
byte[] b = s.Cast<byte>().ToArray();
Encoding.Default.GetBytes(s) which, by the way, is way faster. Quick testing suggests that Encoding.Default.GetBytes(s) performs at least 79% faster. YMMV. –
Pulpiteer €. This code will not crash, but will return a wrong result (which is even worse). Try casting to a short instead of byte to see the difference. –
Obtrude Simply use this:
byte[] myByte= System.Text.ASCIIEncoding.Default.GetBytes(myString);
System.Text.ASCIIEncoding.Default.GetBytes("Árvíztűrő tükörfúrógép.").ToString(); will return "Árvizturo tukörfurogép." losing information which can not be retrieved. (And I didn't yet mention asian languages where you would loose all characters.) –
Chirlin A character is both a lookup key into a font table and a lexical tradition such as ordering, upper and lower case versions, etc.
Consequently, a character is not a byte (8-bits) and a byte is not a character. In particular, the 256 permutations of a byte cannot accommodate the thousands of symbols within some written languages, much less all languages. Hence, various methods for encoding characters have been devised. Some encode for a particular class of languages (ASCII encoding); multiple languages using code pages (Extended ASCII); or, ambitiously, all languages by selectively including additional bytes as needed, Unicode.
Within a system, such as the .NET framework, a String implies a particular character encoding. In .NET this encoding is Unicode. Since the framework reads and writes Unicode by default, dealing with character encoding is typically not necessary in .NET.
However, in general, to load a character string into the system from a byte stream you need to know the source encoding to therefore interpret and subsequently translate it correctly (otherwise the codes will be taken as already being in the system's default encoding and thus render gibberish). Similarly, when a string is written to an external source, it will be written in a particular encoding.
I have written a Visual Basic extension similar to the accepted answer, but directly using .NET memory and Marshalling for conversion, and it supports character ranges unsupported in other methods, like UnicodeEncoding.UTF8.GetString or UnicodeEncoding.UTF32.GetString or even MemoryStream and BinaryFormatter (invalid characters like: & ChrW(55906) & ChrW(55655)):
<Extension> _
Public Function ToBytesMarshal(ByRef str As String) As Byte()
Dim gch As GCHandle = GCHandle.Alloc(str, GCHandleType.Pinned)
Dim handle As IntPtr = gch.AddrOfPinnedObject
ToBytesMarshal = New Byte(str.Length * 2 - 1) {}
Try
For i As Integer = 0 To ToBytesMarshal.Length - 1
ToBytesMarshal.SetValue(Marshal.ReadByte(IntPtr.Add(handle, i)), i)
Next
Finally
gch.Free()
End Try
End Function
<Extension> _
Public Function ToStringMarshal(ByRef arr As Byte()) As String
Dim gch As GCHandle = GCHandle.Alloc(arr, GCHandleType.Pinned)
Try
ToStringMarshal = Marshal.PtrToStringAuto(gch.AddrOfPinnedObject)
Finally
gch.Free()
End Try
End Function
To convert a string to a byte[] use the following solution:
string s = "abcdefghijklmnopqrstuvwxyz";
byte[] b = System.Text.UTF32Encoding.GetBytes(s);
I hope it helps.
s.Select(e => (byte)e) this only works for ASCII characters. But the char type is for storing UTF16 Units. Now after your editing, the code is at least correct, but it varies from environment to environment, hence rendering it virtually useless. IMHO Encoding.Default should only be used for interacting with legacy Windows "Ansi codepage" code. –
Warrantable byte[] b = System.Text.UTF32Encoding.GetBytes(s);, UTF8 is equally fine. –
Warrantable From byte[] to string:
return BitConverter.ToString(bytes);
// C# to convert a string to a byte array.
public static byte[] StrToByteArray(string str)
{
System.Text.ASCIIEncoding encoding=new System.Text.ASCIIEncoding();
return encoding.GetBytes(str);
}
// C# to convert a byte array to a string.
byte [] dBytes = ...
string str;
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
str = enc.GetString(dBytes);
Here is the code:
// Input string.
const string input = "Dot Net Perls";
// Invoke GetBytes method.
// ... You can store this array as a field!
byte[] array = Encoding.ASCII.GetBytes(input);
// Loop through contents of the array.
foreach (byte element in array)
{
Console.WriteLine("{0} = {1}", element, (char)element);
}
I had to convert a string to a byte array for a serial communication project - I had to handle 8-bit characters, and I was unable to find a method using the framework converters to do so that didn't either add two-byte entries or mis-translate the bytes with the eighth bit set. So I did the following, which works:
string message = "This is a message.";
byte[] bytes = new byte[message.Length];
for (int i = 0; i < message.Length; i++)
bytes[i] = (byte)message[i];
OP's question: "How do I convert a string to a byte array in .NET (C#)?" [sic]
You can use the following code:
static byte[] ConvertString (string s) {
return new byte[0];
}
As a benefit, encoding does not matter! Oh wait, this is an ecoding... it's just trivial and highly lossy.
© 2022 - 2024 — McMap. All rights reserved.
charis astructthat just happens to currently store values as a 16-bit number (UTF-16). What you're really asking (get the character bytes) isn't theoretically possible because it doesn't theoretically exist. Acharorstringhas no Encoding by definition. What if the memory representation changed to UTF-32? Your "get the bytes, shove them back" would fail due to Encoding because you avoided Encoding. So "Why this dependency on encoding?!!!" Depend on Encoding so your code is dependable. – MarcumSystem.Text.Encoding.Unicode.GetBytes();is doing some kind of expensive conversion that you want to avoid? If so, your assumption is wrong. – Rabbitvar array1 = yourString.ToCharArray();If for some reason you want the code units asUInt16values, dovar array2 = Array.ConvertAll<char, ushort>(array1, x => x);. That is aushort[]there. – Flameproof