Determinar a codificação de uma string em c #

Existe alguma maneira de determinar a codificação de uma string em c #?

Digamos, eu tenho uma string de nome de arquivo, mas eu não sei se ela está codificada em Unicode UTF-16 ou a codificação padrão do sistema, como eu descubro?

Confira o Utf8Checker, é uma class simples que faz exatamente isso no código gerenciado puro. http://utf8checker.codeplex.com

Aviso: como já foi mencionado, “determine a codificação” faz sentido apenas para streams de bytes. Se você tiver uma string, ela já está codificada de alguém que já conheceu ou adivinhou a codificação para obter a string em primeiro lugar.

O código abaixo tem os seguintes resources:

  1. Detecção ou tentativa de detecção de UTF-7, UTF-8/16/32 (bom, nenhum bom, pequeno e grande endian)
  2. Volta para a página de códigos padrão local se nenhuma codificação Unicode for encontrada.
  3. Detecta (com alta probabilidade) arquivos unicode com a lista de materiais / assinatura ausente
  4. Procura por charset = xyz e codificação = xyz dentro do arquivo para ajudar a determinar a codificação.
  5. Para salvar o processamento, você pode ‘provar’ o arquivo (número de bytes definível).
  6. A codificação e o arquivo de texto decodificado são retornados.
  7. Solução baseada em bytes puramente para eficiência

Como outros já disseram, nenhuma solução pode ser perfeita (e certamente não é fácil diferenciar entre as várias codificações ASCII de 8 bits em uso em todo o mundo), mas podemos ficar “boas o suficiente” especialmente se o desenvolvedor também apresentar ao usuário uma lista de codificações alternativas, como mostrado aqui: Qual é a codificação mais comum de cada idioma?

Uma lista completa de codificações pode ser encontrada usando Encoding.GetEncodings();

 // Function to detect the encoding for UTF-7, UTF-8/16/32 (bom, no bom, little // & big endian), and local default codepage, and potentially other codepages. // 'taster' = number of bytes to check of the file (to save processing). Higher // value is slower, but more reliable (especially UTF-8 with special characters // later on may appear to be ASCII initially). If taster = 0, then taster // becomes the length of the file (for maximum reliability). 'text' is simply // the string with the discovered encoding applied to the file. public Encoding detectTextEncoding(string filename, out String text, int taster = 1000) { byte[] b = File.ReadAllBytes(filename); //////////////// First check the low hanging fruit by checking if a //////////////// BOM/signature exists (sourced from http://www.unicode.org/faq/utf_bom.html#bom4) if (b.Length >= 4 && b[0] == 0x00 && b[1] == 0x00 && b[2] == 0xFE && b[3] == 0xFF) { text = Encoding.GetEncoding("utf-32BE").GetString(b, 4, b.Length - 4); return Encoding.GetEncoding("utf-32BE"); } // UTF-32, big-endian else if (b.Length >= 4 && b[0] == 0xFF && b[1] == 0xFE && b[2] == 0x00 && b[3] == 0x00) { text = Encoding.UTF32.GetString(b, 4, b.Length - 4); return Encoding.UTF32; } // UTF-32, little-endian else if (b.Length >= 2 && b[0] == 0xFE && b[1] == 0xFF) { text = Encoding.BigEndianUnicode.GetString(b, 2, b.Length - 2); return Encoding.BigEndianUnicode; } // UTF-16, big-endian else if (b.Length >= 2 && b[0] == 0xFF && b[1] == 0xFE) { text = Encoding.Unicode.GetString(b, 2, b.Length - 2); return Encoding.Unicode; } // UTF-16, little-endian else if (b.Length >= 3 && b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF) { text = Encoding.UTF8.GetString(b, 3, b.Length - 3); return Encoding.UTF8; } // UTF-8 else if (b.Length >= 3 && b[0] == 0x2b && b[1] == 0x2f && b[2] == 0x76) { text = Encoding.UTF7.GetString(b,3,b.Length-3); return Encoding.UTF7; } // UTF-7 //////////// If the code reaches here, no BOM/signature was found, so now //////////// we need to 'taste' the file to see if can manually discover //////////// the encoding. A high taster value is desired for UTF-8 if (taster == 0 || taster > b.Length) taster = b.Length; // Taster size can't be bigger than the filesize obviously. // Some text files are encoded in UTF8, but have no BOM/signature. Hence // the below manually checks for a UTF8 pattern. This code is based off // the top answer at: https://stackoverflow.com/questions/6555015/check-for-invalid-utf8 // For our purposes, an unnecessarily strict (and terser/slower) // implementation is shown at: https://stackoverflow.com/questions/1031645/how-to-detect-utf-8-in-plain-c // For the below, false positives should be exceedingly rare (and would // be either slightly malformed UTF-8 (which would suit our purposes // anyway) or 8-bit extended ASCII/UTF-16/32 at a vanishingly long shot). int i = 0; bool utf8 = false; while (i < taster - 4) { if (b[i] <= 0x7F) { i += 1; continue; } // If all characters are below 0x80, then it is valid UTF8, but UTF8 is not 'required' (and therefore the text is more desirable to be treated as the default codepage of the computer). Hence, there's no "utf8 = true;" code unlike the next three checks. if (b[i] >= 0xC2 && b[i] <= 0xDF && b[i + 1] >= 0x80 && b[i + 1] < 0xC0) { i += 2; utf8 = true; continue; } if (b[i] >= 0xE0 && b[i] <= 0xF0 && b[i + 1] >= 0x80 && b[i + 1] < 0xC0 && b[i + 2] >= 0x80 && b[i + 2] < 0xC0) { i += 3; utf8 = true; continue; } if (b[i] >= 0xF0 && b[i] <= 0xF4 && b[i + 1] >= 0x80 && b[i + 1] < 0xC0 && b[i + 2] >= 0x80 && b[i + 2] < 0xC0 && b[i + 3] >= 0x80 && b[i + 3] < 0xC0) { i += 4; utf8 = true; continue; } utf8 = false; break; } if (utf8 == true) { text = Encoding.UTF8.GetString(b); return Encoding.UTF8; } // The next check is a heuristic attempt to detect UTF-16 without a BOM. // We simply look for zeroes in odd or even byte places, and if a certain // threshold is reached, the code is 'probably' UF-16. double threshold = 0.1; // proportion of chars step 2 which must be zeroed to be diagnosed as utf-16. 0.1 = 10% int count = 0; for (int n = 0; n < taster; n += 2) if (b[n] == 0) count++; if (((double)count) / taster > threshold) { text = Encoding.BigEndianUnicode.GetString(b); return Encoding.BigEndianUnicode; } count = 0; for (int n = 1; n < taster; n += 2) if (b[n] == 0) count++; if (((double)count) / taster > threshold) { text = Encoding.Unicode.GetString(b); return Encoding.Unicode; } // (little-endian) // Finally, a long shot - let's see if we can find "charset=xyz" or // "encoding=xyz" to identify the encoding: for (int n = 0; n < taster-9; n++) { if ( ((b[n + 0] == 'c' || b[n + 0] == 'C') && (b[n + 1] == 'h' || b[n + 1] == 'H') && (b[n + 2] == 'a' || b[n + 2] == 'A') && (b[n + 3] == 'r' || b[n + 3] == 'R') && (b[n + 4] == 's' || b[n + 4] == 'S') && (b[n + 5] == 'e' || b[n + 5] == 'E') && (b[n + 6] == 't' || b[n + 6] == 'T') && (b[n + 7] == '=')) || ((b[n + 0] == 'e' || b[n + 0] == 'E') && (b[n + 1] == 'n' || b[n + 1] == 'N') && (b[n + 2] == 'c' || b[n + 2] == 'C') && (b[n + 3] == 'o' || b[n + 3] == 'O') && (b[n + 4] == 'd' || b[n + 4] == 'D') && (b[n + 5] == 'i' || b[n + 5] == 'I') && (b[n + 6] == 'n' || b[n + 6] == 'N') && (b[n + 7] == 'g' || b[n + 7] == 'G') && (b[n + 8] == '=')) ) { if (b[n + 0] == 'c' || b[n + 0] == 'C') n += 8; else n += 9; if (b[n] == '"' || b[n] == '\'') n++; int oldn = n; while (n < taster && (b[n] == '_' || b[n] == '-' || (b[n] >= '0' && b[n] <= '9') || (b[n] >= 'a' && b[n] <= 'z') || (b[n] >= 'A' && b[n] <= 'Z'))) { n++; } byte[] nb = new byte[n-oldn]; Array.Copy(b, oldn, nb, 0, n-oldn); try { string internalEnc = Encoding.ASCII.GetString(nb); text = Encoding.GetEncoding(internalEnc).GetString(b); return Encoding.GetEncoding(internalEnc); } catch { break; } // If C# doesn't recognize the name of the encoding, break. } } // If all else fails, the encoding is probably (though certainly not // definitely) the user's local codepage! One might present to the user a // list of alternative encodings as shown here: https://stackoverflow.com/questions/8509339/what-is-the-most-common-encoding-of-each-language // A full list can be found using Encoding.GetEncodings(); text = Encoding.Default.GetString(b); return Encoding.Default; } 

Depende de onde a string ‘veio’. Uma string do .NET é Unicode (UTF-16). A única maneira que poderia ser diferente se você, digamos, ler os dados de um database em uma matriz de bytes.

Este artigo do CodeProject pode ser interessante: Detectar Codificação para texto recebido e enviado

As Strings em C # e .NET do Jon Skeet são uma excelente explicação das strings .NET.

Eu sei que isso é um pouco tarde – mas para ser claro:

Uma string realmente não tem codificação … no .net, a string é uma coleção de objects char. Essencialmente, se é uma string, já foi decodificada.

No entanto, se você estiver lendo o conteúdo de um arquivo, que é feito de bytes, e quiser convertê-lo em uma string, então a codificação do arquivo deve ser usada.

O .NET inclui classs de codificação e decodificação para: ASCII, UTF7, UTF8, UTF32 e mais.

A maioria dessas codificações contém certas marcas de ordem de byte que podem ser usadas para distinguir qual tipo de codificação foi usado.

A class .NET System.IO.StreamReader é capaz de determinar a codificação usada em um stream, lendo essas marcas de ordem de byte;

Aqui está um exemplo:

  ///  /// return the detected encoding and the contents of the file. ///  ///  ///  ///  public static Encoding DetectEncoding(String fileName, out String contents) { // open the file with the stream-reader: using (StreamReader reader = new StreamReader(fileName, true)) { // read the contents of the file into a string contents = reader.ReadToEnd(); // return the encoding. return reader.CurrentEncoding; } } 

Outra opção, muito tardia, desculpe:

http://www.architectshack.com/TextFileEncodingDetector.ashx

Essa pequena class C # -only usa o BOMS, se presente, tenta detectar automaticamente possíveis codificações unicode, e retrocede se nenhuma das codificações Unicode for possível ou provável.

Parece que o UTF8Checker mencionado acima faz algo semelhante, mas acho que isso é um pouco mais amplo no escopo – em vez de apenas UTF8, ele também procura por outras codificações Unicode possíveis (UTF-16 LE ou BE) que podem estar faltando uma BOM.

Espero que isso ajude alguém!

Minha solução é usar materiais internos com alguns substitutos.

Eu escolhi a estratégia de uma resposta para outra pergunta semelhante no stackoverflow, mas não consigo encontrá-la agora.

Ele verifica primeiro o BOM usando a lógica integrada no StreamReader, se houver BOM, a codificação será algo diferente de Encoding.Default e devemos confiar nesse resultado.

Caso contrário, verifica se a seqüência de bytes é uma seqüência UTF-8 válida. se for, ele irá adivinhar UTF-8 como a codificação, e se não, novamente, a codificação ASCII padrão será o resultado.

 static Encoding getEncoding(string path) { var stream = new FileStream(path, FileMode.Open); var reader = new StreamReader(stream, Encoding.Default, true); reader.Read(); if (reader.CurrentEncoding != Encoding.Default) { reader.Close(); return reader.CurrentEncoding; } stream.Position = 0; reader = new StreamReader(stream, new UTF8Encoding(false, true)); try { reader.ReadToEnd(); reader.Close(); return Encoding.UTF8; } catch (Exception) { reader.Close(); return Encoding.Default; } } 

O pacote Nuget SimpleHelpers.FileEncoding envolve uma porta C # do Mozilla Universal Charset Detector em uma API morta simples:

 var encoding = FileEncoding.DetectFileEncoding(txtFile); 

Nota: esta foi uma experiência para ver como a codificação UTF-8 funcionou internamente. A solução oferecida pelo vilicvane , para usar um object UTF8Encoding que é inicializado para lançar uma exceção na falha de decodificação, é muito mais simples e basicamente faz a mesma coisa.


Eu escrevi este pedaço de código para diferenciar entre UTF-8 e Windows-1252. Ele não deve ser usado para arquivos de texto gigantescos, já que carrega a coisa toda na memory e a examina completamente. Eu usei para arquivos de legendas .srt, apenas para poder salvá-los de volta na codificação em que foram carregados.

A codificação dada à function como ref deve ser a codificação de fallback de 8 bits a ser usada caso o arquivo seja detectado como não sendo válido UTF-8; geralmente, nos sistemas Windows, isso será o Windows-1252. Isto não faz nada extravagante como verificar as faixas ascii válidas reais, e não detecta o UTF-16 mesmo na marca de ordem de byte.

A teoria por trás da detecção bit a bit pode ser encontrada aqui: https://ianthehenry.com/2015/1/17/decoding-utf-8/

Basicamente, o intervalo de bits do primeiro byte determina quantos deles fazem parte da entidade UTF-8. Esses bytes depois estão sempre no mesmo intervalo de bits.

 ///  /// Detects whether the encoding of the data is valid UTF-8 or ascii. If detection fails, the text is decoded using the given fallback encoding. /// Bit-wise mechanism for detecting valid UTF-8 based on https://ianthehenry.com/2015/1/17/decoding-utf-8/ /// Note that pure ascii detection should not be trusted: it might mean the file is meant to be UTF-8 or Windows-1252 but simply contains no special characters. ///  /// The bytes of the text document. /// The default encoding to use as fallback if the text is detected not to be pure ascii or UTF-8 compliant. This ref parameter is changed to the detected encoding, or Windows-1252 if the given encoding parameter is null and the text is not valid UTF-8. /// The contents of the read file public static String ReadFileAndGetEncoding(Byte[] docBytes, ref Encoding encoding) { if (encoding == null) encoding = Encoding.GetEncoding(1252); // BOM detection is not added in this example. Add it yourself if you feel like it. Should set the "encoding" param and return the decoded string. //String file = DetectByBOM(docBytes, ref encoding); //if (file != null) // return file; Boolean isPureAscii = true; Boolean isUtf8Valid = true; for (Int32 i = 0; i < docBytes.Length; i++) { Int32 skip = TestUtf8(docBytes, i); if (skip != 0) { if (isPureAscii) isPureAscii = false; if (skip < 0) isUtf8Valid = false; else i += skip; } // if already detected that it's not valid utf8, there's no sense in going on. if (!isUtf8Valid) break; } if (isPureAscii) encoding = new ASCIIEncoding(); // pure 7-bit ascii. else if (isUtf8Valid) encoding = new UTF8Encoding(false); // else, retain given fallback encoding. return encoding.GetString(docBytes); } ///  /// Tests if the bytes following the given offset are UTF-8 valid, and returns /// the extra amount of bytes to skip ahead to do the next read if it is /// (meaning, detecting a single-byte ascii character would return 0). /// If the text is not UTF-8 valid it returns -1. ///  /// Byte array to test /// Offset in the byte array to test. /// The amount of extra bytes to skip ahead for the next read, or -1 if the byte sequence wasn't valid UTF-8 public static Int32 TestUtf8(Byte[] binFile, Int32 offset) { Byte current = binFile[offset]; if ((current & 0x80) == 0) return 0; // valid 7-bit ascii. Added length is 0 bytes. else { Int32 len = binFile.Length; Int32 fullmask = 0xC0; Int32 testmask = 0; for (Int32 addedlength = 1; addedlength < 6; addedlength++) { // This code adds shifted bits to get the desired full mask. // If the full mask is [111]0 0000, then test mask will be [110]0 0000. Since this is // effectively always the previous step in the iteration I just store it each time. testmask = fullmask; fullmask += (0x40 >> addedlength); // Test bit mask for this level if ((current & fullmask) == testmask) { // End of file. Might be cut off, but either way, deemed invalid. if (offset + addedlength >= len) return -1; else { // Lookahead. Pattern of any following bytes is always 10xxxxxx for (Int32 i = 1; i <= addedlength; i++) { // If it does not match the pattern for an added byte, it is deemed invalid. if ((binFile[offset + i] & 0xC0) != 0x80) return -1; } return addedlength; } } } // Value is greater than the start of a 6-byte utf8 sequence. Deemed invalid. return -1; } }