Determinar a codificação de uma string em C #


127

Existe alguma maneira de determinar a codificação de uma seqüência de caracteres em c #?

Digamos, eu tenho uma string de nome de arquivo, mas não sei se ela está codificada no Unicode UTF-16 ou na codificação padrão do sistema, como descubro?


Você não pode "codificar" em Unicode. E não há como determinar automaticamente a codificação de qualquer String, sem nenhuma outra informação prévia.
Nicolas Dumazet 22/06/2009

5
para ficar mais claro, talvez: você codifique pontos de código Unicode em cadeias de bytes de um conjunto de caracteres usando um esquema de "codificação" (utf- , iso- , big5, shift-jis, etc ...) e decodifique cadeias de bytes de um conjunto de caracteres para Unicode. Você não codifica cadeias de caracteres em Unicode. Você não decodifica Unicode em cadeias de caracteres.
Nicolas Dumazet

13
@NicDunZ - a codificação em si (em particular UTF-16) também é comumente chamada de "Unicode". Certo ou errado, isso é vida. Mesmo no .NET, consulte Encoding.Unicode - que significa UTF-16.
Marc Gravell

2
oh bem, eu não sabia que o .NET era tão enganoso. Parece um hábito terrível de aprender. E @krebstar desculpe, isso não era minha intenção (eu ainda acho que sua pergunta editada faz muito mais sentido agora do que antes)
Nicolas Dumazet

1
@ Nicdumz # 1: Existe uma maneira de determinar probabilisticamente qual codificação usar. Veja o que o IE (e agora também o FF com Exibir - Codificação de caracteres - Detecção automática) faz isso: ele tenta uma codificação e vê se está possivelmente "bem escrito <coloque um nome de idioma aqui>" ou muda e tenta novamente . Vamos lá, isso pode ser divertido!
22410 SnippyHolloW

Respostas:


31

Confira Utf8Checker: é uma classe simples que faz exatamente isso em código gerenciado puro. http://utf8checker.codeplex.com

Nota: como já foi indicado, "determinar codificação" faz sentido apenas para fluxos de bytes. Se você tiver uma sequência, ela já será codificada por alguém que já conheceu ou adivinhou a codificação para obtê-la em primeiro lugar.


Se a seqüência de caracteres é uma decodificação incorreta feita com uma codificação de 8 bits e você tem a codificação usada para decodificá-la, normalmente é possível recuperar os bytes sem corrupção.
precisa saber é o seguinte

57

O código abaixo possui os seguintes recursos:

  1. Detecção ou tentativa de detecção de UTF-7, UTF-8/16/32 (bom, não bom, pequeno e grande endian)
  2. Volta para a página de código padrão local se nenhuma codificação Unicode foi encontrada.
  3. Detecta (com alta probabilidade) arquivos unicode com a BOM / assinatura ausente
  4. Procura por charset = xyz e codificação = xyz dentro do arquivo para ajudar a determinar a codificação.
  5. Para salvar o processamento, você pode 'provar' o arquivo (número definível de bytes).
  6. O arquivo de texto codificado e decodificado é retornado.
  7. Solução puramente baseada em bytes para eficiência

Como outros já disseram, nenhuma solução pode ser perfeita (e certamente não se pode diferenciar facilmente entre as várias codificações ASCII estendidas de 8 bits em uso no mundo), mas podemos ser "bons o suficiente", especialmente se o desenvolvedor também apresentar ao usuário uma lista de codificações alternativas, como mostrado aqui: Qual é a codificação mais comum de cada idioma?

Uma lista completa de codificações pode ser encontrada usando 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;
}

Isso funciona para arquivos cirílico (e provavelmente todos os outros) .eml (do cabeçalho do conjunto de caracteres do email)
Nime Cloud

UTF-7 não pode ser decodificado de maneira tão ingênua, na verdade; seu preâmbulo completo é mais longo e inclui dois bits do primeiro caractere. O sistema .Net parece não ter suporte algum ao preâmbulo do UTF7.
Nyerguds

Funcionou para mim quando nenhum dos outros métodos que verifiquei não ajudou! Obrigado Dan.
Tejasvi Hegde

Obrigado pela sua solução. Estou usando para determinar a codificação em arquivos de fontes completamente diferentes. O que eu descobri, porém, é que, se eu usar um valor muito baixo de provador, o resultado pode estar errado. (por exemplo, o código estava retornando Encoding.Default para um arquivo UTF8, mesmo que eu estivesse usando b.Length / 10 como meu provador.) Então, comecei a me perguntar: qual é o argumento para usar um provador menor que b.Length? Parece que só posso concluir que Encoding.Default é aceitável se e somente se eu tiver verificado o arquivo inteiro.
30516 Sean

@ Sea: É para quando a velocidade importa mais que a precisão, especialmente para arquivos que podem ter dezenas ou centenas de megabytes de tamanho. Na minha experiência, mesmo um valor baixo de provador pode produzir resultados corretos ~ 99,9% das vezes. Sua experiência pode ser diferente.
Dan W

33

Depende de onde a string 'veio'. Uma cadeia .NET é Unicode (UTF-16). A única maneira de ser diferente se você, por exemplo, ler os dados de um banco de dados em uma matriz de bytes.

Este artigo do CodeProject pode ser interessante: Detectar codificação para texto de entrada e saída

As seqüências de caracteres de Jon Skeet em C # e .NET são uma excelente explicação para seqüências de caracteres .NET.


Ela veio de um aplicativo não-Unicode C ++ .. O artigo CodeProject parece um pouco demasiado complexo, no entanto, parece fazer o que eu quero fazer .. Obrigado ..
krebstar

18

Eu sei que isso é um pouco tarde - mas para deixar claro:

Uma string realmente não tem codificação ... no .NET, a string é uma coleção de objetos char. Essencialmente, se for uma string, já foi decodificada.

No entanto, se você estiver lendo o conteúdo de um arquivo, que é composto de bytes, e desejar convertê-lo em uma string, será necessário usar a codificação do arquivo.

O .NET inclui classes de codificação e decodificação para: ASCII, UTF7, UTF8, UTF32 e muito mais.

A maioria dessas codificações contém determinadas marcas de ordem de bytes que podem ser usadas para distinguir qual tipo de codificação foi usado.

A classe .NET System.IO.StreamReader pode determinar a codificação usada em um fluxo, lendo essas marcas de ordem de bytes;

Aqui está um exemplo:

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

3
Isso não funcionará para detectar UTF 16 sem a BOM. Nem retornará à página de códigos padrão local do usuário se ele não detectar nenhuma codificação unicode. Você pode corrigir o último adicionando Encoding.Defaultcomo um parâmetro StreamReader, mas o código não detectará UTF8 sem a BOM.
Dan W

1
@ DanW: O UTF-16 sem BOM é realmente feito? Eu nunca usaria isso; é provável que seja um desastre abrir praticamente qualquer coisa.
Nyerguds

11

Outra opção, muito tarde, desculpe:

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

Essa pequena classe C #-only usa BOMS, se presente, tenta detectar automaticamente possíveis codificações unicode, caso contrário, e recua se nenhuma das codificações Unicode for possível ou provável.

Parece que o UTF8Checker mencionado acima faz algo semelhante, mas acho que esse é um escopo um pouco mais amplo - em vez de apenas UTF8, ele também verifica outras possíveis codificações Unicode (UTF-16 LE ou BE) que podem estar faltando em uma lista técnica.

Espero que isso ajude alguém!


Código agradável bastante, ele resolveu o meu problema de codificação de detecção :)
CARLOS LOTH

9

O pacote SimpleHelpers.FileEncoding Nuget agrupa uma porta C # do Mozilla Universal Charset Detector em uma API simples:

var encoding = FileEncoding.DetectFileEncoding(txtFile);

este deve ser mais alto, ele fornece uma solução muito simples: deixar que outros façam o trabalho: D
buddybubble

Esta biblioteca é GPL
A abr

É isso? Eu vejo uma licença do MIT e ela usa um componente de licença tripla (UDE), um dos quais é MPL. Eu tenho tentado determinar se o UDE era problemático para um produto proprietário; portanto, se você tiver mais informações, isso será muito apreciado.
Simon Woods

5

Minha solução é usar materiais embutidos com alguns fallbacks.

Escolhi a estratégia de uma resposta para outra pergunta semelhante no stackoverflow, mas não consigo encontrá-la agora.

Ele verifica primeiro a lista técnica usando a lógica interna do StreamReader; se houver lista técnica, a codificação será outra Encoding.Default, e devemos confiar nesse resultado.

Caso contrário, verifica se a sequência de bytes é uma sequência UTF-8 válida. se for, adivinha UTF-8 como a codificação; caso contrário, novamente, a codificação ASCII padrão será o resultado.

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

3

Nota: este foi um experimento para ver como a codificação UTF-8 funcionava internamente. A solução oferecida pela vilicvane , para usar um UTF8Encodingobjeto inicializado para lançar uma exceção na falha de decodificação, é muito mais simples e basicamente faz a mesma coisa.


Eu escrevi este pedaço de código para diferenciar entre UTF-8 e Windows-1252. Porém, ele não deve ser usado para arquivos de texto gigantescos, pois carrega a coisa toda na memória e a digitaliza completamente. Usei-o para arquivos de legenda .srt, apenas para salvá-los na codificação em que foram carregados.

A codificação fornecida para a função como ref deve ser a codificação de fallback de 8 bits a ser usada caso o arquivo seja detectado como não sendo válido UTF-8; geralmente, nos sistemas Windows, será o Windows-1252. No entanto, isso não é nada chique, como verificar as faixas válidas de ascii válidas e não detecta UTF-16 nem na ordem dos bytes.

A teoria por trás da detecção bit a bit pode ser encontrada aqui: https://ianthehenry.com/2015/1/17/decoding-utf-8/

Basicamente, o intervalo de bits do primeiro byte determina quantos depois faz parte da entidade UTF-8. Esses bytes depois estão sempre no mesmo intervalo de bits.

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

Também não há última elsedeclaração depois if ((current & 0xE0) == 0xC0) { ... } else if ((current & 0xF0) == 0xE0) { ... } else if ((current & 0xF0) == 0xE0) { ... } else if ((current & 0xF8) == 0xF0) { ... }. Suponho que esse elsecaso seria utf8: inválido isUtf8Valid = false;. Você iria?
hal

@hal Ah, é verdade ... Desde então, atualizei meu próprio código com um sistema mais geral (e mais avançado) que usa um loop que vai até 3, mas pode tecnicamente ser alterado para um loop ainda mais (as especificações são um pouco claras nesse sentido). ; é possível expandir o UTF-8 em até 6 bytes adicionais, eu acho, mas apenas 3 são usados ​​nas implementações atuais); portanto, não atualizei esse código.
precisa saber é o seguinte

@hal Atualizei para minha nova solução. O princípio permanece o mesmo, mas as máscaras de bits são criadas e verificadas em um loop, em vez de todas explicitamente gravadas no código.
Nyerguds

1

Encontrei uma nova biblioteca no GitHub: CharsetDetector / UTF-unknown

Detector de conjunto de caracteres compilado em C # - .NET Core 2-3, .NET padrão 1-2 e .NET 4+

também é uma porta do Mozilla Universal Charset Detector com base em outros repositórios.

CharsetDetector / UTF-unknown tem uma classe chamada CharsetDetector.

CharsetDetector contém alguns métodos de detecção de codificação estática:

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

resultado detectado está na classe DetectionResulttem atributo Detectedque é instância da classe DetectionDetailcom os atributos abaixo:

  • EncodingName
  • Encoding
  • Confidence

Abaixo está um exemplo para mostrar o uso:

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

captura de tela do resultado de exemplo: insira a descrição da imagem aqui

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.