Strip the byte order mark from string in C#

I recently had issues with the .NET 4 upgrade, but until then the simple answer is

String.Trim()

removes the BOM up until .NET 3.5.

However, in .NET 4 you need to change it slightly:

String.Trim(new char[]{'\uFEFF'}); 

That will also get rid of the byte order mark, though you may also want to remove the ZERO WIDTH SPACE (U+200B):

String.Trim(new char[]{'\uFEFF','\u200B'}); 

This you could also use to remove other unwanted characters.

Some further information is from String.Trim Method:

The .NET Framework 3.5 SP1 and earlier versions maintain an internal list of white-space characters that this method trims. Starting with the .NET Framework 4, the method trims all Unicode white-space characters (that is, characters that produce a true return value when they are passed to the Char.IsWhiteSpace method). Because of this change, the Trim method in the .NET Framework 3.5 SP1 and earlier versions removes two characters, ZERO WIDTH SPACE (U+200B) and ZERO WIDTH NO-BREAK SPACE (U+FEFF), that the Trim method in the .NET Framework 4 and later versions does not remove. In addition, the Trim method in the .NET Framework 3.5 SP1 and earlier versions does not trim three Unicode white-space characters: MONGOLIAN VOWEL SEPARATOR (U+180E), NARROW NO-BREAK SPACE (U+202F), and MEDIUM MATHEMATICAL SPACE (U+205F).

I had some incorrect test data, which caused me some confusion. Based on How to avoid tripping over UTF-8 BOM when reading files I found that this worked:

private readonly string _byteOrderMarkUtf8 = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble()); public string GetXmlResponse(Uri resource) { string xml; using (var client = new WebClient()) { client.Encoding = Encoding.UTF8; xml = client.DownloadString(resource); } if (xml.StartsWith(_byteOrderMarkUtf8, StringComparison.Ordinal)) { xml = xml.Remove(0, _byteOrderMarkUtf8.Length); } return xml; } 

Setting the client Encoding property correctly reduces the BOM to a single character. However, XDocument.Parse still will not read that string. This is the cleanest version I've come up with to date.

This works as well

int index = xmlResponse.IndexOf('<'); if (index > 0) { xmlResponse = xmlResponse.Substring(index, xmlResponse.Length - index); } 

A quick and simple method to remove it directly from a string:

private static string RemoveBom(string p) { string BOMMarkUtf8 = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble()); if (p.StartsWith(BOMMarkUtf8, StringComparison.Ordinal)) p = p.Remove(0, BOMMarkUtf8.Length); return p.Replace("\0", ""); } 

How to use it:

string yourCleanString=RemoveBom(yourBOMString); 

Note that StringComparison.Ordinal is important as, depending on the culture the thread is running under, the BOM can be interpreted as an empty string by StartsWith and will always return true. Ordinal will compare the string using binary sort rules.

I had a very similar problem (I needed to parse an XML document represented as a byte array that had a byte order mark at the beginning of it). I used one of Martin's comments on his answer to come to a solution. I took the byte array I had (instead of converting it to a string) and created a MemoryStream object with it. Then I passed it to XDocument.Load, which worked like a charm. For example, let's say that xmlBytes contains your XML in UTF-8 encoding with a byte mark at the beginning of it. Then, this would be the code to solve the problem:

var stream = new MemoryStream(xmlBytes); var document = XDocument.Load(stream); 

It's that simple.

If starting out with a string, it should still be easy to do (assume xml is your string containing the XML with the byte order mark):

var bytes = Encoding.UTF8.GetBytes(xml); var stream = new MemoryStream(bytes); var document = XDocument.Load(stream); 

I wrote the following post after coming across this issue.

Essentially instead of reading in the raw bytes of the file's contents using the BinaryReader class, I use the StreamReader class with a specific constructor which automatically removes the byte order mark character from the textual data I am trying to retrieve.

It's of course best if you can strip it out while still on the byte array level to avoid unwanted substrings / allocs. But if you already have a string, this is perhaps the easiest and most performant way to handle this.

Usage:

 string feed = ""; // input bool hadBOM = FixBOMIfNeeded(ref feed); var xElem = XElement.Parse(feed); // now does not fail 

 /// <summary> /// You can get this or test it originally with: Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble())[0]; /// But no need, this way we have a constant. As these three bytes `[239, 187, 191]` (a BOM) evaluate to a single C# char. /// </summary> public const char BOMChar = (char)65279; public static bool FixBOMIfNeeded(ref string str) { if (string.IsNullOrEmpty(str)) return false; bool hasBom = str[0] == BOMChar; if (hasBom) str = str.Substring(1); return hasBom; } 

Pass the byte buffer (via DownloadData) to string Encoding.UTF8.GetString(byte[]) to get the string rather than download the buffer as a string. You probably have more problems with your current method than just trimming the byte order mark. Unless you're properly decoding it as I suggest here, Unicode characters will probably be misinterpreted, resulting in a corrupted string.

Martin's answer is better, since it avoids allocating an entire string for XML that still needs to be parsed anyway. The answer I gave best applies to general strings that don't need to be parsed as XML.

I ran into this when I had a Base64 encoded file to transform into the string. While I could have saved it to a file and then read it correctly, here's the best solution I could think of to get from the byte[] of the file to the string (based lightly on TrueWill's answer):

public static string GetUTF8String(byte[] data) { byte[] utf8Preamble = Encoding.UTF8.GetPreamble(); if (data.StartsWith(utf8Preamble)) { return Encoding.UTF8.GetString(data, utf8Preamble.Length, data.Length - utf8Preamble.Length); } else { return Encoding.UTF8.GetString(data); } } 

Where StartsWith(byte[]) is the logical extension:

public static bool StartsWith(this byte[] thisArray, byte[] otherArray) { // Handle invalid/unexpected input // (nulls, thisArray.Length < otherArray.Length, etc.) for (int i = 0; i < otherArray.Length; ++i) { if (thisArray[i] != otherArray[i]) { return false; } } return true; } 

StreamReader sr = new StreamReader(strFile, true); XmlDocument xdoc = new XmlDocument(); xdoc.Load(sr); 

Yet another generic variation to get rid of the UTF-8 BOM preamble:

var preamble = Encoding.UTF8.GetPreamble(); if (!functionBytes.Take(preamble.Length).SequenceEqual(preamble)) preamble = Array.Empty<Byte>(); return Encoding.UTF8.GetString(functionBytes, preamble.Length, functionBytes.Length - preamble.Length); 

Use a regex replace to filter out any other characters other than the alphanumeric characters and spaces that are contained in a normal certificate thumbprint value:

certficateThumbprint = Regex.Replace(certficateThumbprint, @"[^a-zA-Z0-9\-\s*]", ""); 

And there you go. Voila!! It worked for me.

I solved the issue with the following code

using System.Xml.Linq; void method() { byte[] bytes = GetXmlBytes(); XDocument doc; using (var stream = new MemoryStream(docBytes)) { doc = XDocument.Load(stream); } }