Określ kodowanie ciągu w C #

Czy istnieje sposób, aby określić kodowanie ciągu w C #?

Powiedzmy, że mam ciąg znaków z nazwą pliku, ale nie wiem, czy jest on zakodowany w Unicode UTF-16, czy w domyślnym kodowaniu systemu, jak mogę się dowiedzieć?

Sprawdź Utf8Checker to prosta klasa, która robi dokładnie to w czystym kodzie zarządzanym. http://utf8checker.codeplex.com

Uwaga: jak już wspomniano, "określ kodowanie" ma sens tylko dla strumieni bajtów. Jeśli masz ciąg, jest on już zakodowany przez kogoś po drodze, który już znał lub odgadł kodowanie, aby uzyskać ciąg w pierwszej kolejności.

Poniższy kod ma następujące cechy:

1. Wykrywanie lub próba wykrycia UTF-7, UTF-8/16/32 (bom, no bom, little & big endian)
2. Powraca do lokalnej domyślnej strony kodowej, jeśli nie znaleziono kodowania Unicode.
3. Wykrywa (z dużym prawdopodobieństwem) pliki Unicode z brakującym BOM / podpisem
4. Wyszukuje charset = xyz i encoding = xyz wewnątrz pliku, aby pomóc określić kodowanie.
5. Aby zaoszczędzić przetwarzanie, możesz „posmakować” pliku (zdefiniowana liczba bajtów).
6. Zwracany jest kodowany i zdekodowany plik tekstowy.
7. Rozwiązanie oparte wyłącznie na bajtach zapewniające wydajność

Jak powiedzieli inni, żadne rozwiązanie nie może być doskonałe (iz pewnością nie można łatwo rozróżnić różnych 8-bitowych rozszerzonych kodowań ASCII używanych na całym świecie), ale możemy uzyskać `` wystarczająco dobre '', zwłaszcza jeśli programista również przedstawi użytkownikowi lista alternatywnych kodowań, jak pokazano tutaj: Jakie jest najpopularniejsze kodowanie w każdym języku?

Pełną listę kodowań można znaleźć za pomocą 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;
}

To zależy, skąd pochodzi ciąg znaków. Ciąg .NET to Unicode (UTF-16). Jedynym sposobem może być inaczej, jeśli, powiedzmy, wczytujesz dane z bazy danych do tablicy bajtów.

Ten artykuł w CodeProject może być interesujący: Wykryj kodowanie dla tekstu przychodzącego i wychodzącego

Ciągi Jona Skeeta w językach C # i .NET to doskonałe wyjaśnienie ciągów .NET.

Wiem, że to trochę późno - ale żeby było jasne:

Łańcuch tak naprawdę nie ma kodowania ... w .NET łańcuch jest zbiorem obiektów typu char. Zasadniczo, jeśli jest to ciąg, został już zdekodowany.

Jeśli jednak czytasz zawartość pliku, który składa się z bajtów, i chcesz przekonwertować ją na łańcuch, należy użyć kodowania pliku.

NET zawiera klasy kodowania i dekodowania dla: ASCII, UTF7, UTF8, UTF32 i innych.

Większość z tych kodowań zawiera określone znaczniki kolejności bajtów, których można użyć do rozróżnienia użytego typu kodowania.

Klasa .NET System.IO.StreamReader jest w stanie określić kodowanie używane w strumieniu, odczytując te znaczniki kolejności bajtów;

Oto przykład:

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

Inna opcja, bardzo późno, przepraszam:

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

Ta mała klasa C #-only używa BOMS, jeśli jest obecna, próbuje automatycznie wykryć możliwe kodowanie Unicode w przeciwnym razie i cofa się, jeśli żadne z kodowań Unicode nie jest możliwe lub prawdopodobne.

Wygląda na to, że wspomniany powyżej UTF8Checker robi coś podobnego, ale myślę, że ma nieco szerszy zakres - zamiast tylko UTF8, sprawdza również inne możliwe kodowania Unicode (UTF-16 LE lub BE), w których może brakować BOM.

Mam nadzieję, że to komuś pomoże!

Pakiet SimpleHelpers.FileEncoding Nuget opakowuje port C # narzędzia Mozilla Universal Charset Detector w martwy prosty interfejs API:

var encoding = FileEncoding.DetectFileEncoding(txtFile);

Moim rozwiązaniem jest użycie wbudowanych elementów z pewnymi wadami.

Wybrałem strategię z odpowiedzi na inne podobne pytanie dotyczące stackoverflow, ale nie mogę jej teraz znaleźć.

Najpierw sprawdza BOM za pomocą wbudowanej logiki w StreamReader, jeśli istnieje BOM, kodowanie będzie inne niż Encoding.Defaulti powinniśmy ufać temu wynikowi.

Jeśli nie, sprawdza, czy sekwencja bajtów jest poprawną sekwencją UTF-8. jeśli tak, zgadnie UTF-8 jako kodowanie, a jeśli nie, ponownie, wynikiem będzie domyślne kodowanie ASCII.

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

Uwaga: był to eksperyment mający na celu sprawdzenie, jak kodowanie UTF-8 działa wewnętrznie. Rozwiązanie oferowane przez vilicvane , polegające na użyciu UTF8Encodingobiektu zainicjowanego w celu wyrzucenia wyjątku w przypadku niepowodzenia dekodowania, jest znacznie prostsze i zasadniczo robi to samo.

Napisałem ten fragment kodu, aby odróżnić UTF-8 od Windows-1252. Nie należy go jednak używać do gigantycznych plików tekstowych, ponieważ ładuje całość do pamięci i całkowicie skanuje. Użyłem go do plików napisów .srt, aby móc je z powrotem zapisać w kodowaniu, w którym zostały załadowane.

Kodowanie nadane funkcji jako ref powinno być 8-bitowym kodowaniem rezerwowym, które ma być używane w przypadku wykrycia pliku jako nieprawidłowego UTF-8; ogólnie w systemach Windows będzie to Windows-1252. Nie robi to jednak niczego wymyślnego, jak sprawdzanie rzeczywistych prawidłowych zakresów ascii i nie wykrywa UTF-16 nawet na znaku kolejności bajtów.

Teorię wykrywania bitowego można znaleźć tutaj: https://ianthehenry.com/2015/1/17/decoding-utf-8/

Zasadniczo zakres bitów pierwszego bajtu określa, ile po nim jest częścią jednostki UTF-8. Te bajty po nim są zawsze w tym samym zakresie bitów.

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

Znalazłem nową bibliotekę na GitHub: CharsetDetector / UTF-unknown

Detektor znaków zbudowany w C # - .NET Core 2-3, .NET standard 1-2 i .NET 4+

jest to również port Mozilla Universal Charset Detector oparty na innych repozytoriach.

CharsetDetector / UTF-unknown mają klasę o nazwie CharsetDetector.

CharsetDetector zawiera kilka statycznych metod wykrywania kodowania:

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

wykryty wynik jest w klasie DetectionResultma atrybut Detectedbędący instancją klasy DetectionDetailo poniższych atrybutach:

• EncodingName
• Encoding
• Confidence

poniżej znajduje się przykład pokazujący użycie:

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

przykładowy zrzut ekranu wyniku: