Bestimmen Sie die Codierung eines Strings in C #

Gibt es eine Möglichkeit, die Codierung eines Strings in C # zu bestimmen?

Angenommen, ich habe eine Dateinamenzeichenfolge, weiß aber nicht, ob diese in Unicode UTF-16 oder in der Systemstandardcodierung codiert ist. Wie finde ich das heraus?

Schauen Sie sich Utf8Checker an, es ist eine einfache Klasse, die genau dies in rein verwaltetem Code tut. http://utf8checker.codeplex.com

Hinweis: Wie bereits erwähnt, ist "Codierung bestimmen" nur für Byte-Streams sinnvoll. Wenn Sie eine Zeichenfolge haben, wird diese bereits von jemandem auf dem Weg codiert, der die Codierung bereits kannte oder erraten hat, um die Zeichenfolge überhaupt zu erhalten.

Der folgende Code hat die folgenden Funktionen:

1. Erkennung oder versuchter Nachweis von UTF-7, UTF-8/16/32 (bom, no bom, Little & Big Endian)
2. Geht auf die lokale Standardcodepage zurück, wenn keine Unicode-Codierung gefunden wurde.
3. Erkennt (mit hoher Wahrscheinlichkeit) Unicode-Dateien mit fehlender Stückliste / Signatur
4. Sucht in der Datei nach charset = xyz und encoding = xyz, um die Codierung zu bestimmen.
5. Um die Verarbeitung zu speichern, können Sie die Datei "probieren" (definierbare Anzahl von Bytes).
6. Die codierte und decodierte Textdatei wird zurückgegeben.
7. Rein bytebasierte Lösung für Effizienz

Wie andere gesagt haben, kann keine Lösung perfekt sein (und sicherlich kann man nicht leicht zwischen den verschiedenen weltweit verwendeten erweiterten 8-Bit-ASCII-Codierungen unterscheiden), aber wir können "gut genug" werden, insbesondere wenn der Entwickler dem Benutzer auch präsentiert Eine Liste alternativer Codierungen, wie hier gezeigt: Was ist die häufigste Codierung für jede Sprache?

Eine vollständige Liste der Codierungen finden Sie mit 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: /programming/6555015/check-for-invalid-utf8
    // For our purposes, an unnecessarily strict (and terser/slower)
    // implementation is shown at: /programming/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: /programming/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;
}

Es hängt davon ab, woher die Zeichenfolge stammt. Eine .NET-Zeichenfolge ist Unicode (UTF-16). Die einzige Möglichkeit könnte anders sein, wenn Sie beispielsweise die Daten aus einer Datenbank in ein Byte-Array lesen.

Dieser CodeProject-Artikel könnte von Interesse sein: Codierung für eingehenden und ausgehenden Text erkennen

Jon Skeets Strings in C # und .NET sind eine hervorragende Erklärung für .NET-Strings.

Ich weiß, dass dies etwas spät ist - aber um es klar zu sagen:

Eine Zeichenfolge hat nicht wirklich eine Codierung. In .NET ist die Zeichenfolge a eine Sammlung von Zeichenobjekten. Wenn es sich um eine Zeichenfolge handelt, wurde sie im Wesentlichen bereits dekodiert.

Wenn Sie jedoch den Inhalt einer Datei lesen, die aus Bytes besteht, und diese in eine Zeichenfolge konvertieren möchten, muss die Codierung der Datei verwendet werden.

.NET enthält Codierungs- und Decodierungsklassen für: ASCII, UTF7, UTF8, UTF32 und mehr.

Die meisten dieser Codierungen enthalten bestimmte Zeichen für die Bytereihenfolge, anhand derer unterschieden werden kann, welcher Codierungstyp verwendet wurde.

Die .NET-Klasse System.IO.StreamReader kann die in einem Stream verwendete Codierung ermitteln, indem diese Markierungen für die Bytereihenfolge gelesen werden.

Hier ist ein Beispiel:

    /// <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;
        }
    }

Eine weitere Option, die sehr spät kommt, sorry:

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

Diese kleine C # -nur-Klasse verwendet Stücklisten, falls vorhanden, versucht, mögliche Unicode-Codierungen andernfalls automatisch zu erkennen, und greift zurück, wenn keine der Unicode-Codierungen möglich oder wahrscheinlich ist.

Es hört sich so an, als ob UTF8Checker, auf das oben verwiesen wurde, etwas Ähnliches tut, aber ich denke, dies ist etwas breiter gefasst - statt nur UTF8 wird auch nach anderen möglichen Unicode-Codierungen (UTF-16 LE oder BE) gesucht, bei denen möglicherweise eine Stückliste fehlt.

Hoffe das hilft jemandem!

Das SimpleHelpers.FileEncoding Nuget Paket wickelt eine C # Port des Mozilla Universal - Charset Detector in eine tote einfache API:

var encoding = FileEncoding.DetectFileEncoding(txtFile);

Meine Lösung besteht darin, eingebaute Dinge mit einigen Fallbacks zu verwenden.

Ich habe die Strategie aus einer Antwort auf eine andere ähnliche Frage zum Stapelüberlauf ausgewählt, kann sie aber jetzt nicht finden.

Die Stückliste wird zuerst mithilfe der in StreamReader integrierten Logik überprüft. Wenn eine Stückliste vorhanden ist, ist die Codierung etwas anderes als Encoding.Default , und wir sollten diesem Ergebnis vertrauen.

Wenn nicht, wird geprüft, ob die Bytesequenz eine gültige UTF-8-Sequenz ist. Wenn dies der Fall ist, wird UTF-8 als Codierung erraten, und wenn nicht, ist die Standard-ASCII-Codierung das Ergebnis.

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;
    }
}

Hinweis: Dies war ein Experiment, um zu sehen, wie die UTF-8-Codierung intern funktioniert. Die von vilicvane angebotene Lösung , ein UTF8EncodingObjekt zu verwenden, das initialisiert wird, um eine Ausnahme bei einem Decodierungsfehler auszulösen , ist viel einfacher und macht im Grunde das Gleiche.

Ich habe diesen Code geschrieben, um zwischen UTF-8 und Windows-1252 zu unterscheiden. Es sollte jedoch nicht für gigantische Textdateien verwendet werden, da es das gesamte Objekt in den Speicher lädt und es vollständig scannt. Ich habe es für .srt-Untertiteldateien verwendet, um sie wieder in der Codierung speichern zu können, in die sie geladen wurden.

Die Codierung, die der Funktion als Referenz zugewiesen wird, sollte die 8-Bit-Fallback-Codierung sein, die verwendet wird, wenn festgestellt wird, dass die Datei nicht gültig ist. UTF-8; Auf Windows-Systemen ist dies im Allgemeinen Windows-1252. Dies macht jedoch nichts Besonderes wie das Überprüfen der tatsächlich gültigen ASCII-Bereiche und erkennt UTF-16 selbst bei der Byte-Reihenfolge nicht.

Die Theorie hinter der bitweisen Erkennung finden Sie hier: https://ianthehenry.com/2015/1/17/decoding-utf-8/

Grundsätzlich bestimmt der Bitbereich des ersten Bytes, wie viele, nachdem es Teil der UTF-8-Entität ist. Diese Bytes danach liegen immer im gleichen Bitbereich.

/// <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;
}

Ich habe auf GitHub eine neue Bibliothek gefunden: CharsetDetector / UTF-unknown

Zeichensatzdetektor in C # - .NET Core 2-3, .NET Standard 1-2 und .NET 4+

Es ist auch ein Port des Mozilla Universal Charset Detector, der auf anderen Repositorys basiert.

CharsetDetector / UTF-unknown haben eine Klasse mit dem Namen CharsetDetector.

CharsetDetector enthält einige Methoden zur Erkennung statischer Codierungen:

• CharsetDetector.DetectFromFile()
• CharsetDetector.DetectFromStream()
• CharsetDetector.DetectFromBytes()

Das erkannte Ergebnis ist in der Klasse DetectionResulthat ein Attribut, Detecteddas eine Instanz der Klasse DetectionDetailmit den folgenden Attributen ist:

• EncodingName
• Encoding
• Confidence

Im Folgenden finden Sie ein Beispiel für die Verwendung:

// Program.cs
using System;
using System.Text;
using UtfUnknown;

namespace ConsoleExample
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string filename = @"E:\new-file.txt";
            DetectDemo(filename);
        }

        /// <summary>
        /// Command line example: detect the encoding of the given file.
        /// </summary>
        /// <param name="filename">a filename</param>
        public static void DetectDemo(string filename)
        {
            // Detect from File
            DetectionResult result = CharsetDetector.DetectFromFile(filename);
            // Get the best Detection
            DetectionDetail resultDetected = result.Detected;

            // detected result may be null.
            if (resultDetected != null)
            {
                // Get the alias of the found encoding
                string encodingName = resultDetected.EncodingName;
                // Get the System.Text.Encoding of the found encoding (can be null if not available)
                Encoding encoding = resultDetected.Encoding;
                // Get the confidence of the found encoding (between 0 and 1)
                float confidence = resultDetected.Confidence;

                if (encoding != null)
                {
                    Console.WriteLine($"Detection completed: {filename}");
                    Console.WriteLine($"EncodingWebName: {encoding.WebName}{Environment.NewLine}Confidence: {confidence}");
                }
                else
                {
                    Console.WriteLine($"Detection completed: {filename}");
                    Console.WriteLine($"(Encoding is null){Environment.NewLine}EncodingName: {encodingName}{Environment.NewLine}Confidence: {confidence}");
                }
            }
            else
            {
                Console.WriteLine($"Detection failed: {filename}");
            }
        }
    }
}

Beispiel Ergebnis Screenshot: