C＃で文字列のエンコードを決定する

C＃で文字列のエンコーディングを決定する方法はありますか？

たとえば、ファイル名の文字列がありますが、それがUnicode UTF-16でエンコードされているのか、システムのデフォルトのエンコードでエンコードされているのかわかりません。どうすれば確認できますか？

Utf8Checkerを確認してください。純粋なマネージコードでこれを正確に実行する単純なクラスです。 http://utf8checker.codeplex.com

注意：すでに指摘したように、「エンコーディングの決定」はバイトストリームに対してのみ意味があります。文字列がある場合、その文字列を最初に取得するためにすでにエンコードを知っているまたは推測した誰かから文字列が既にエンコードされています。

以下のコードには次の機能があります。

1. UTF-7、UTF-8 / 16/32（bom、no bom、リトル＆ビッグエンディアン）の検出または検出の試み
2. Unicodeエンコーディングが見つからなかった場合、ローカルのデフォルトコードページにフォールバックします。
3. BOM /署名が欠落しているUnicodeファイルを（高い確率で）検出します
4. ファイル内でcharset = xyzおよびencoding = 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記事は興味深いかもしれません：受信および送信テキストのエンコーディングの検出

Jon Skeetの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＃のみのクラスは、存在する場合はBOMSを使用し、それ以外の場合は可能なUnicodeエンコーディングを自動検出しようとし、Unicodeエンコーディングがまったくないか、可能性がない場合はフォールバックします。

上記のUTF8Checkerも同様のことをしているようですが、これは範囲がやや広いと思います。UTF8だけでなく、BOMが欠落している可能性のある他の可能なUnicodeエンコーディング（UTF-16 LEまたはBE）もチェックします。

これが誰かを助けることを願っています！

SimpleHelpers.FileEncoding Nugetパッケージは、ラップMozillaのユニバーサル文字セット検出器のC＃のポートをデッドシンプルなAPIに：

var encoding = FileEncoding.DetectFileEncoding(txtFile);

私の解決策は、いくつかのフォールバックを備えた組み込みのものを使用することです。

私はスタックオーバーフローに関する別の同様の質問への回答から戦略を選びましたが、今は見つかりません。

まず、StreamReaderの組み込みロジックを使用してBOMをチェックします。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として関数に与えられるエンコーディングは、ファイルが有効なUTF-8ではないと検出された場合に使用する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}");
            }
        }
    }
}

結果のスクリーンショットの例：