Визначте кодування рядка в C #

Чи є спосіб визначити кодування рядка в C #?

Скажімо, у мене є рядок з назвою файлу, але я не знаю, чи він закодований в Unicode UTF-16 або кодування за замовчуванням для системи, як це дізнатися?

Перевірте Utf8Checker - це простий клас, який робить саме це в чистому керованому коді. http://utf8checker.codeplex.com

Зауважте: як уже вказувалося, "визначити кодування" має сенс лише для потоків байтів. Якщо у вас є рядок, вона вже кодується у когось із тих, хто вже знав або здогадався про кодування, щоб отримати рядок в першу чергу.

Код нижче має такі особливості:

1. Виявлення або спроба виявлення UTF-7, UTF-8/16/32 (бом, без бомби, маленький та великий ендіан)
2. Повертається до локальної кодової сторінки за замовчуванням, якщо кодування Unicode не знайдено.
3. Виявляє (з великою часткою ймовірності) файли Unicode, у яких відсутні BOM / підпис
4. Шукає charset = xyz та кодування = xyz всередині файлу, щоб визначити кодування.
5. Щоб зберегти обробку, ви можете "пробувати" файл (визначається кількість байтів).
6. Повертається текстовий файл кодування та декодованого тексту.
7. Суто байтове рішення для ефективності

Як зазначають інші, жодне рішення не може бути ідеальним (і, звичайно, не можна легко розрізнити різні 8-бітні розширені кодування ASCII, що використовуються у всьому світі), але ми можемо отримати "достатньо хорошого", особливо якщо розробник також подає користувачеві список альтернативних кодувань, як показано тут: Що є найпоширенішим кодуванням кожної мови?

Повний список кодувань можна знайти за допомогою 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;
}

Це залежить від того, звідки "походить рядок". Рядок .NET - це Unicode (UTF-16). Єдиний спосіб може бути інакше, якби ви, скажімо, прочитали дані з бази даних в масив байтів.

Ця стаття CodeProject може представляти інтерес: Виявити кодування для вхідного та вихідного тексту

Струни Джона Скіта в C # і .NET - це відмінне пояснення рядків .NET.

Я знаю, що це трохи пізно - але щоб було зрозуміло:

Рядок насправді не має кодування ... у .NET рядок - це сукупність об'єктів char. По суті, якщо це рядок, вона вже була розшифрована.

Однак якщо ви читаєте вміст файлу, який складається з байтів, і хочете перетворити його в рядок, тоді слід використовувати кодування файлу.

.NET включає класи кодування та декодування для: ASCII, UTF7, UTF8, UTF32 та багато іншого.

Більшість цих кодувань містять певні позначки порядку байтів, які можна використовувати для розрізнення того, який тип кодування використовувався.

Клас .NET System.IO.StreamReader може визначити кодування, яке використовується в потоці, зчитуючи ці позначки порядку байтів;

Ось приклад:

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

Ще один варіант, дуже пізно прийшов, вибачте:

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

Цей невеликий клас C # -only використовує BOMS, якщо він присутній, намагається автоматично виявити можливі кодування Unicode в іншому випадку і відступає, якщо жодне з кодувань Unicode не можливе або ймовірно.

Здається, що UTF8Checker, на який згадувалося вище, робить щось подібне, але я думаю, що це трохи ширший обсяг - замість просто UTF8 він також перевіряє інші можливі кодування Unicode (UTF-16 LE або BE), у яких може бути відсутнім BOM.

Сподіваюся, це комусь допоможе!

Пакет SimpleHelpers.FileEncoding Nuget обертає порт C # універсального детектора шаблонів Mozilla в мертвий простий API:

var encoding = FileEncoding.DetectFileEncoding(txtFile);

Моє рішення - використовувати вбудовані елементи з деякими резервними копіями.

Я вибрав стратегію з відповіді на інше подібне питання щодо stackoverflow, але зараз не можу її знайти.

Він спочатку перевіряє BOM, використовуючи вбудовану логіку в StreamReader, якщо BOM є, кодування буде чимось іншим, ніж Encoding.Default , і ми повинні довіряти цьому результату.

Якщо ні, то він перевіряє, чи байтова послідовність є дійсною послідовністю UTF-8. якщо він є, він здогадається UTF-8 як кодування, а якщо ні, знову ж таки, кодування 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;
    }
}

Примітка. Це був експеримент, щоб побачити, як кодування UTF-8 працює всередині. Рішення, запропоноване vilicvane , використовувати UTF8Encodingоб'єкт, який ініціалізується, щоб кинути виняток на помилку декодування, набагато простіше, і в основному робить те ж саме.

Я написав цей фрагмент коду, щоб розрізняти UTF-8 і Windows-1252. Він не повинен використовуватися для гігантських текстових файлів, оскільки він завантажує всю річ у пам'ять і повністю її сканує. Я використовував його для .srt-файлів субтитрів, просто щоб мати змогу зберегти їх назад у кодуванні, в яке вони були завантажені.

Кодування, надане функції як ref, має бути 8-бітним резервним кодуванням, яке слід використовувати у випадку, якщо файл виявлено як недійсний UTF-8; як правило, для систем Windows це буде Windows-1252. Це не робить нічого фантазійного, як перевірка дійсних дійсних діапазонів ascii, але не виявляє UTF-16 навіть на байтовій позначці порядку.

Теорію, що стоїть за розрядним розпізнаванням, можна знайти тут: https://ianthehenry.com/2015/1/17/decoding-utf-8/

В основному, бітовий діапазон першого байта визначає кількість після того, як він є частиною сутності UTF-8. Ці байти після нього завжди знаходяться в одному бітовому діапазоні.

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

Я знайшов нову бібліотеку на GitHub: CharsetDetector / UTF-unknown

Вбудований шарсетний детектор в C # - .NET Core 2-3, .NET стандарт 1-2 & .NET 4+

це також порт Mozilla Universal Charset Detector на основі інших сховищ.

CharsetDetector / UTF-unknown мають клас з іменем CharsetDetector.

CharsetDetector містить кілька методів виявлення статичного кодування:

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

Виявлений результат знаходиться в класі DetectionResultмає атрибут, Detectedякий є екземпляром класу DetectionDetailз атрибутами нижче:

• EncodingName
• Encoding
• Confidence

нижче - приклад показу використання:

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

приклад скріншоту результату: