Skuteczny sposób na znalezienie kodowania dowolnego pliku

Tak, to najczęściej zadawane pytanie, a ta sprawa jest dla mnie niejasna, a ponieważ niewiele o niej wiem.

Ale chciałbym bardzo precyzyjny sposób znaleźć kodowanie plików. Tak precyzyjny jak Notepad ++.

StreamReader.CurrentEncodingNieruchomość rzadko zwraca poprawny plik tekstowy kodujący dla mnie. Odniosłem większy sukces w określaniu endianness pliku, analizując jego znacznik kolejności bajtów (BOM). Jeśli plik nie ma BOM, nie może to określić kodowania pliku.

* ZAKTUALIZOWANO 4/08/2020 w celu uwzględnienia wykrywania UTF-32LE i przywrócenia prawidłowego kodowania dla UTF-32BE

/// <summary>
/// Determines a text file's encoding by analyzing its byte order mark (BOM).
/// Defaults to ASCII when detection of the text file's endianness fails.
/// </summary>
/// <param name="filename">The text file to analyze.</param>
/// <returns>The detected encoding.</returns>
public static Encoding GetEncoding(string filename)
{
    // Read the BOM
    var bom = new byte[4];
    using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read))
    {
        file.Read(bom, 0, 4);
    }

    // Analyze the BOM
    if (bom[0] == 0x2b && bom[1] == 0x2f && bom[2] == 0x76) return Encoding.UTF7;
    if (bom[0] == 0xef && bom[1] == 0xbb && bom[2] == 0xbf) return Encoding.UTF8;
    if (bom[0] == 0xff && bom[1] == 0xfe && bom[2] == 0 && bom[3] == 0) return Encoding.UTF32; //UTF-32LE
    if (bom[0] == 0xff && bom[1] == 0xfe) return Encoding.Unicode; //UTF-16LE
    if (bom[0] == 0xfe && bom[1] == 0xff) return Encoding.BigEndianUnicode; //UTF-16BE
    if (bom[0] == 0 && bom[1] == 0 && bom[2] == 0xfe && bom[3] == 0xff) return new UTF32Encoding(true, true);  //UTF-32BE

    // We actually have no idea what the encoding is if we reach this point, so
    // you may wish to return null instead of defaulting to ASCII
    return Encoding.ASCII;
}

Poniższy kod działa dobrze dla mnie, używając StreamReaderklasy:

  using (var reader = new StreamReader(fileName, defaultEncodingIfNoBom, true))
  {
      reader.Peek(); // you need this!
      var encoding = reader.CurrentEncoding;
  }

Sztuczka polega na użyciu Peekwywołania, w przeciwnym razie .NET nic nie zrobił (i nie przeczytał preambuły, BOM). Oczywiście, jeśli użyjesz innego ReadXXXwywołania przed sprawdzeniem kodowania, to też zadziała.

Jeśli plik nie ma BOM, defaultEncodingIfNoBomzostanie użyte kodowanie. Istnieje również StreamReader bez tej metody przeciążania (w tym przypadku domyślne kodowanie (ANSI) będzie używane jako defaultEncodingIfNoBom), ale zalecam zdefiniowanie tego, co uważasz za domyślne kodowanie w twoim kontekście.

Przetestowałem to pomyślnie z plikami z BOM dla UTF8, UTF16 / Unicode (LE i BE) i UTF32 (LE i BE). Nie działa z UTF7.

Spróbowałbym następujących kroków:

1) Sprawdź, czy istnieje znacznik kolejności bajtów

2) Sprawdź, czy plik jest prawidłowy w formacie UTF8

3) Użyj lokalnej strony kodowej „ANSI” (ANSI zgodnie z definicją firmy Microsoft)

Krok 2 działa, ponieważ większość sekwencji innych niż ASCII w stronach kodowych innych niż UTF8 nie jest prawidłowym kodem UTF8.

Sprawdź to.

UDE

To jest port Mozilla Universal Charset Detector i możesz go używać w ten sposób ...

public static void Main(String[] args)
{
    string filename = args[0];
    using (FileStream fs = File.OpenRead(filename)) {
        Ude.CharsetDetector cdet = new Ude.CharsetDetector();
        cdet.Feed(fs);
        cdet.DataEnd();
        if (cdet.Charset != null) {
            Console.WriteLine("Charset: {0}, confidence: {1}", 
                 cdet.Charset, cdet.Confidence);
        } else {
            Console.WriteLine("Detection failed.");
        }
    }
}

Podanie szczegółów implementacji dla kroków proponowanych przez @CodesInChaos:

1) Sprawdź, czy istnieje znacznik kolejności bajtów

2) Sprawdź, czy plik jest prawidłowy w formacie UTF8

3) Użyj lokalnej strony kodowej „ANSI” (ANSI zgodnie z definicją firmy Microsoft)

Krok 2 działa, ponieważ większość sekwencji innych niż ASCII w stronach kodowych innych niż UTF8 nie jest prawidłowym kodem UTF8. https://stackoverflow.com/a/4522251/867248 wyjaśnia szczegółowo taktykę.

using System; using System.IO; using System.Text;

// Using encoding from BOM or UTF8 if no BOM found,
// check if the file is valid, by reading all lines
// If decoding fails, use the local "ANSI" codepage

public string DetectFileEncoding(Stream fileStream)
{
    var Utf8EncodingVerifier = Encoding.GetEncoding("utf-8", new EncoderExceptionFallback(), new DecoderExceptionFallback());
    using (var reader = new StreamReader(fileStream, Utf8EncodingVerifier,
           detectEncodingFromByteOrderMarks: true, leaveOpen: true, bufferSize: 1024))
    {
        string detectedEncoding;
        try
        {
            while (!reader.EndOfStream)
            {
                var line = reader.ReadLine();
            }
            detectedEncoding = reader.CurrentEncoding.BodyName;
        }
        catch (Exception e)
        {
            // Failed to decode the file using the BOM/UT8. 
            // Assume it's local ANSI
            detectedEncoding = "ISO-8859-1";
        }
        // Rewind the stream
        fileStream.Seek(0, SeekOrigin.Begin);
        return detectedEncoding;
   }
}


[Test]
public void Test1()
{
    Stream fs = File.OpenRead(@".\TestData\TextFile_ansi.csv");
    var detectedEncoding = DetectFileEncoding(fs);

    using (var reader = new StreamReader(fs, Encoding.GetEncoding(detectedEncoding)))
    {
       // Consume your file
        var line = reader.ReadLine();
        ...

Poniższe kody są moimi kodami Powershell do określenia, czy niektóre pliki cpp, h lub ml są kodowane za pomocą ISO-8859-1 (Latin-1) lub UTF-8 bez BOM, jeśli żaden z nich nie powinien być GB18030. Jestem Chińczykiem pracującym we Francji i MSVC zapisuje jako Latin-1 na francuskim komputerze i zapisuje jako GB na chińskim komputerze, więc pomaga mi to uniknąć problemów z kodowaniem podczas wymiany plików źródłowych między moim systemem a kolegami.

Sposób jest prosty, jeśli wszystkie znaki są między x00-x7E, ASCII, UTF-8 i Latin-1 są takie same, ale jeśli przeczytam plik inny niż ASCII przez UTF-8, znajdziemy znak specjalny pojawi się , więc spróbuj czytać z Latin-1. W Latin-1 między \ x7F a \ xAF jest puste, podczas gdy GB używa pełnego między x00-xFF, więc jeśli mam coś między nimi, nie jest to Latin-1

Kod jest napisany w PowerShell, ale używa .net, więc można go łatwo przetłumaczyć na C # lub F #

$Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding($False)
foreach($i in Get-ChildItem .\ -Recurse -include *.cpp,*.h, *.ml) {
    $openUTF = New-Object System.IO.StreamReader -ArgumentList ($i, [Text.Encoding]::UTF8)
    $contentUTF = $openUTF.ReadToEnd()
    [regex]$regex = '�'
    $c=$regex.Matches($contentUTF).count
    $openUTF.Close()
    if ($c -ne 0) {
        $openLatin1 = New-Object System.IO.StreamReader -ArgumentList ($i, [Text.Encoding]::GetEncoding('ISO-8859-1'))
        $contentLatin1 = $openLatin1.ReadToEnd()
        $openLatin1.Close()
        [regex]$regex = '[\x7F-\xAF]'
        $c=$regex.Matches($contentLatin1).count
        if ($c -eq 0) {
            [System.IO.File]::WriteAllLines($i, $contentLatin1, $Utf8NoBomEncoding)
            $i.FullName
        } 
        else {
            $openGB = New-Object System.IO.StreamReader -ArgumentList ($i, [Text.Encoding]::GetEncoding('GB18030'))
            $contentGB = $openGB.ReadToEnd()
            $openGB.Close()
            [System.IO.File]::WriteAllLines($i, $contentGB, $Utf8NoBomEncoding)
            $i.FullName
        }
    }
}
Write-Host -NoNewLine 'Press any key to continue...';
$null = $Host.UI.RawUI.ReadKey('NoEcho,IncludeKeyDown');

.NET nie jest zbyt pomocny, ale możesz wypróbować następujący algorytm:

1. spróbuj znaleźć kodowanie według BOM (znak kolejności bajtów) ... bardzo prawdopodobne, że nie zostanie znaleziony
2. spróbuj przeanalizować różne kodowania

Oto wezwanie:

var encoding = FileHelper.GetEncoding(filePath);
if (encoding == null)
    throw new Exception("The file encoding is not supported. Please choose one of the following encodings: UTF8/UTF7/iso-8859-1");

Oto kod:

public class FileHelper
{
    /// <summary>
    /// Determines a text file's encoding by analyzing its byte order mark (BOM) and if not found try parsing into diferent encodings       
    /// Defaults to UTF8 when detection of the text file's endianness fails.
    /// </summary>
    /// <param name="filename">The text file to analyze.</param>
    /// <returns>The detected encoding or null.</returns>
    public static Encoding GetEncoding(string filename)
    {
        var encodingByBOM = GetEncodingByBOM(filename);
        if (encodingByBOM != null)
            return encodingByBOM;

        // BOM not found :(, so try to parse characters into several encodings
        var encodingByParsingUTF8 = GetEncodingByParsing(filename, Encoding.UTF8);
        if (encodingByParsingUTF8 != null)
            return encodingByParsingUTF8;

        var encodingByParsingLatin1 = GetEncodingByParsing(filename, Encoding.GetEncoding("iso-8859-1"));
        if (encodingByParsingLatin1 != null)
            return encodingByParsingLatin1;

        var encodingByParsingUTF7 = GetEncodingByParsing(filename, Encoding.UTF7);
        if (encodingByParsingUTF7 != null)
            return encodingByParsingUTF7;

        return null;   // no encoding found
    }

    /// <summary>
    /// Determines a text file's encoding by analyzing its byte order mark (BOM)  
    /// </summary>
    /// <param name="filename">The text file to analyze.</param>
    /// <returns>The detected encoding.</returns>
    private static Encoding GetEncodingByBOM(string filename)
    {
        // Read the BOM
        var byteOrderMark = new byte[4];
        using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read))
        {
            file.Read(byteOrderMark, 0, 4);
        }

        // Analyze the BOM
        if (byteOrderMark[0] == 0x2b && byteOrderMark[1] == 0x2f && byteOrderMark[2] == 0x76) return Encoding.UTF7;
        if (byteOrderMark[0] == 0xef && byteOrderMark[1] == 0xbb && byteOrderMark[2] == 0xbf) return Encoding.UTF8;
        if (byteOrderMark[0] == 0xff && byteOrderMark[1] == 0xfe) return Encoding.Unicode; //UTF-16LE
        if (byteOrderMark[0] == 0xfe && byteOrderMark[1] == 0xff) return Encoding.BigEndianUnicode; //UTF-16BE
        if (byteOrderMark[0] == 0 && byteOrderMark[1] == 0 && byteOrderMark[2] == 0xfe && byteOrderMark[3] == 0xff) return Encoding.UTF32;

        return null;    // no BOM found
    }

    private static Encoding GetEncodingByParsing(string filename, Encoding encoding)
    {            
        var encodingVerifier = Encoding.GetEncoding(encoding.BodyName, new EncoderExceptionFallback(), new DecoderExceptionFallback());

        try
        {
            using (var textReader = new StreamReader(filename, encodingVerifier, detectEncodingFromByteOrderMarks: true))
            {
                while (!textReader.EndOfStream)
                {                        
                    textReader.ReadLine();   // in order to increment the stream position
                }

                // all text parsed ok
                return textReader.CurrentEncoding;
            }
        }
        catch (Exception ex) { }

        return null;    // 
    }
}

Poszukaj tutaj c #

https://msdn.microsoft.com/en-us/library/system.io.streamreader.currentencoding%28v=vs.110%29.aspx

string path = @"path\to\your\file.ext";

using (StreamReader sr = new StreamReader(path, true))
{
    while (sr.Peek() >= 0)
    {
        Console.Write((char)sr.Read());
    }

    //Test for the encoding after reading, or at least
    //after the first read.
    Console.WriteLine("The encoding used was {0}.", sr.CurrentEncoding);
    Console.ReadLine();
    Console.WriteLine();
}

Może się przydać

string path = @"address/to/the/file.extension";

using (StreamReader sr = new StreamReader(path))
{ 
    Console.WriteLine(sr.CurrentEncoding);                        
}