Moyen efficace de trouver l'encodage de n'importe quel fichier

Oui est une question très fréquente, et cette question est vague pour moi et puisque je ne sais pas grand chose à ce sujet.

Mais je voudrais une manière très précise de trouver un encodage de fichiers. Aussi précis que l'est Notepad ++.

La StreamReader.CurrentEncodingpropriété renvoie rarement le codage de fichier texte correct pour moi. J'ai eu plus de succès pour déterminer l'endianité d'un fichier, en analysant sa marque d'ordre d'octet (BOM). Si le fichier n'a pas de nomenclature, cela ne peut pas déterminer le codage du fichier.

* MISE À JOUR le 4/08/2020 pour inclure la détection UTF-32LE et renvoyer un encodage correct pour 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;
}

Le code suivant fonctionne très bien pour moi, en utilisant la StreamReaderclasse:

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

L'astuce consiste à utiliser l' Peekappel, sinon .NET n'a rien fait (et il n'a pas lu le préambule, la nomenclature). Bien sûr, si vous utilisez un autre ReadXXXappel avant de vérifier l'encodage, cela fonctionne aussi.

Si le fichier n'a pas de nomenclature, le defaultEncodingIfNoBomcodage sera utilisé. Il existe également un StreamReader sans cette méthode de surcharge (dans ce cas, l'encodage par défaut (ANSI) sera utilisé comme defaultEncodingIfNoBom), mais je vous recommande de définir ce que vous considérez comme l'encodage par défaut dans votre contexte.

J'ai testé cela avec succès avec des fichiers avec BOM pour UTF8, UTF16 / Unicode (LE & BE) et UTF32 (LE & BE). Cela ne fonctionne pas pour UTF7.

J'essaierais les étapes suivantes:

1) Vérifiez s'il y a une marque d'ordre d'octet

2) Vérifiez si le fichier est valide UTF8

3) Utilisez la page de codes locale «ANSI» (ANSI comme le définit Microsoft)

L'étape 2 fonctionne car la plupart des séquences non ASCII des pages de code autres que UTF8 ne sont pas UTF8 valides.

Vérifie ça.

UDE

Ceci est un port de Mozilla Universal Charset Detector et vous pouvez l'utiliser comme ceci ...

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

Fournir les détails d'implémentation des étapes proposées par @CodesInChaos:

1) Vérifiez s'il y a une marque d'ordre d'octet

2) Vérifiez si le fichier est valide UTF8

3) Utilisez la page de codes locale «ANSI» (ANSI comme le définit Microsoft)

L'étape 2 fonctionne car la plupart des séquences non ASCII dans les pages de code autres que UTF8 ne sont pas UTF8 valides. https://stackoverflow.com/a/4522251/867248 explique la tactique plus en détail.

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();
        ...

Les codes suivants sont mes codes Powershell pour déterminer si certains fichiers cpp ou h ou ml sont encodés avec ISO-8859-1 (Latin-1) ou UTF-8 sans BOM, si ni l'un ni l'autre, supposons que ce soit GB18030. Je suis chinois travaillant en France et MSVC enregistre en Latin-1 sur un ordinateur français et enregistre en Go sur un ordinateur chinois, ce qui m'aide à éviter les problèmes d'encodage lors des échanges de fichiers source entre mon système et mes collègues.

Le chemin est simple, si tous les caractères sont entre x00-x7E, ASCII, UTF-8 et Latin-1 sont tous les mêmes, mais si je lis un fichier non ASCII par UTF-8, nous trouverons le caractère spécial apparaître , alors essayez de lire avec Latin-1. En Latin-1, entre \ x7F et \ xAF est vide, tandis que GB utilise plein entre x00-xFF donc si j'en ai entre les deux, ce n'est pas Latin-1

Le code est écrit en PowerShell, mais utilise .net, il est donc facile d'être traduit en C # ou 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 n'est pas très utile, mais vous pouvez essayer l'algorithme suivant:

1. essayez de trouver le codage par BOM (marque d'ordre d'octet) ... très probablement introuvable
2. essayez d'analyser différents encodages

Voici l'appel:

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

Voici le code:

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

Regardez ici pour 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();
}

Cela peut être utile

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

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