Déterminer une chaîne de codage en C#

Le code ci-dessous présente les caractéristiques suivantes:

1. De la détection ou de la tentative de détection de l'encodage UTF-7, UTF-8/16/32 (bom, sans bom, peu & big endian)
2. Descend vers le local de la page de codes par défaut si aucun codage Unicode a été trouvé.
3. Détecte (avec une forte probabilité) des fichiers unicode avec la MOB/signature manquante
4. Recherche charset=xyz et encoding=xyz à l'intérieur de fichiers pour vous aider à déterminer l'encodage.
5. Pour sauver le traitement, vous pouvez le "goût" le fichier (définissable nombre d'octets).
6. L'encodage et le texte décodé fichier est renvoyé.
7. Purement octet à base de solution pour l'efficacité

Comme d'autres l'ont dit, aucune solution ne peut être parfait (et certainement on ne peut pas différencier entre les différents 8 bits ASCII étendu codages utilisés dans le monde entier), mais nous pouvons obtenir "assez bien", surtout si le développeur également présente à l'utilisateur une liste d'autres encodages comme indiqué ici: Qu'est-ce que l'encodage le plus courant de chaque langue?

Une liste complète des Codages peuvent être trouvés en utilisant 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;
}

Je sais c'est un peu tardive mais pour être clair:

Une chaîne n'a pas vraiment de codage... dans .NET le une chaîne de caractères est une collection de char objets. Essentiellement, si c'est une chaîne, il a déjà été décodé.

Cependant, si vous lisez le contenu d'un fichier, qui est faite d'octets, et souhaitez convertir une chaîne de caractères, puis l'encodage du fichier doit être utilisé.

.NET comprend l'encodage et le décodage des classes de: ASCII, UTF7, UTF8, UTF32 et plus.

La plupart de ces codages contenir certaines d'ordre d'octet marques qui peuvent être utilisés pour distinguer le type de codage a été utilisé.

L' .NET de Système de classe.IO.StreamReader est en mesure de déterminer l'encodage utilisé dans un flux, par la lecture de ces l'ordre des octets des marques;

Voici un exemple:

    ///<summary>
///return the detected encoding and the contents of the file.
///</summary>
///<param name="fileName"></param>
///<param name="contents"></param>
///<returns></returns>
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;
}
}

La SimpleHelpers.FileEncoding package Nuget enroule une C# port de Mozilla jeu de caractères Universel Détecteur de dans un cul-de-API simple:

var encoding = FileEncoding.DetectFileEncoding(txtFile);

Remarque: ce fut une expérience pour voir comment le codage UTF-8 a travaillé à l'interne. La solution proposée par vilicvane, l'utilisation d'un UTF8Encoding objet est initialisé à lever une exception sur le décodage de l'échec, est beaucoup plus simple, et se fait de la même chose.

---

J'ai écrit ce morceau de code pour différencier entre UTF-8 et Windows-1252. Il ne devrait pas être utilisé pour de gigantesques fichiers texte, mais, depuis qu'il charge la totalité de la chose dans la mémoire et analyses complètement. Je l'ai utilisé pour .srt sous-titres des fichiers, juste pour être en mesure de les enregistrer en arrière dans l'encodage dans lequel ils ont été chargés.

L'encodage donné à la fonction comme ref devrait être la 8-bits de secours de l'encodage à utiliser dans le cas où le fichier est détecté comme n'étant pas valide UTF-8; en général, sur les systèmes Windows, ce sera Windows-1252. Ce n'est pas faire quelque chose de compliqué, comme la vérification valide ascii gammes de bien, et ne détecte pas l'UTF-16, même sur la marque d'ordre d'octet.

La théorie derrière la bit-à-bit de détection peuvent être trouvés ici:
https://ianthehenry.com/2015/1/17/decoding-utf-8/

Fondamentalement, le peu portée du premier octet détermine combien d'après elle font partie de l'UTF-8 de l'entité. Ces octets après elle sont toujours dans les mêmes bits de large.

///<summary>
///Reads a text file, and detects whether its encoding is valid UTF-8 or ascii.
///If not, decodes the text using the given fallback encoding.
///Bit-wise mechanism for detecting valid UTF-8 based on
///https://ianthehenry.com/2015/1/17/decoding-utf-8/
///</summary>
///<param name="docBytes">The bytes read from the file.</param>
///<param name="encoding">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.</param>
///<returns>The contents of the read file, as String.</returns>
public static String ReadFileAndGetEncoding(Byte[] docBytes, ref Encoding encoding)
{
if (encoding == null)
encoding = Encoding.GetEncoding(1252);
Int32 len = docBytes.Length;
//byte order mark for utf-8. Easiest way of detecting encoding.
if (len > 3 && docBytes[0] == 0xEF && docBytes[1] == 0xBB && docBytes[2] == 0xBF)
{
encoding = new UTF8Encoding(true);
//Note that even when initialising an encoding to have
//a BOM, it does not cut it off the front of the input.
return encoding.GetString(docBytes, 3, len - 3);
}
Boolean isPureAscii = true;
Boolean isUtf8Valid = true;
for (Int32 i = 0; i < len; ++i)
{
Int32 skip = TestUtf8(docBytes, i);
if (skip == 0)
continue;
if (isPureAscii)
isPureAscii = false;
if (skip < 0)
{
isUtf8Valid = false;
//if invalid utf8 is detected, there's no sense in going on.
break;
}
i += skip;
}
if (isPureAscii)
encoding = new ASCIIEncoding(); //pure 7-bit ascii.
else if (isUtf8Valid)
encoding = new UTF8Encoding(false);
//else, retain given encoding. This should be an 8-bit encoding like Windows-1252.
return encoding.GetString(docBytes);
}
///<summary>
///Tests if the bytes following the given offset are UTF-8 valid, and
///returns the amount of bytes to skip ahead to do the next read if it is.
///If the text is not UTF-8 valid it returns -1.
///</summary>
///<param name="binFile">Byte array to test</param>
///<param name="offset">Offset in the byte array to test.</param>
///<returns>The amount of bytes to skip ahead for the next read, or -1 if the byte sequence wasn't valid UTF-8</returns>
public static Int32 TestUtf8(Byte[] binFile, Int32 offset)
{
//7 bytes (so 6 added bytes) is the maximum the UTF-8 design could support,
//but in reality it only goes up to 3, meaning the full amount is 4.
const Int32 maxUtf8Length = 4;
Byte current = binFile[offset];
if ((current & 0x80) == 0)
return 0; //valid 7-bit ascii. Added length is 0 bytes.
Int32 len = binFile.Length;
for (Int32 addedlength = 1; addedlength < maxUtf8Length; ++addedlength)
{
Int32 fullmask = 0x80;
Int32 testmask = 0;
//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.
for (Int32 i = 0; i <= addedlength; ++i)
{
testmask = fullmask;
fullmask += (0x80 >> (i+1));
}
//figure out bit masks from level
if ((current & fullmask) == testmask)
{
if (offset + addedlength >= len)
return -1;
//Lookahead. Pattern of any following bytes is always 10xxxxxx
for (Int32 i = 1; i <= addedlength; ++i)
{
if ((binFile[offset + i] & 0xC0) != 0x80)
return -1;
}
return addedlength;
}
}
//Value is greater than the maximum allowed for utf8. Deemed invalid.
return -1;
}