Partilhar via


Encoding.GetPreamble Método

Definição

Quando substituído em uma classe derivada, retorna uma sequência de bytes que especifica a codificação usada.

public:
 virtual cli::array <System::Byte> ^ GetPreamble();
public virtual byte[] GetPreamble ();
abstract member GetPreamble : unit -> byte[]
override this.GetPreamble : unit -> byte[]
Public Overridable Function GetPreamble () As Byte()

Retornos

Byte[]

Uma matriz de bytes que contém uma sequência de bytes que especifica a codificação usada.

- ou -

Uma matriz de bytes de tamanho zero, se um preâmbulo não for necessário.

Exemplos

O exemplo a seguir determina a ordem de bytes da codificação com base no preâmbulo.

using namespace System;
using namespace System::Text;
int main()
{
   Encoding^ unicode = Encoding::Unicode;
   
   // Get the preamble for the Unicode encoder. 
   // In this case the preamblecontains the Byte order mark (BOM).
   array<Byte>^preamble = unicode->GetPreamble();
   
   // Make sure a preamble was returned 
   // and is large enough to contain a BOM.
   if ( preamble->Length >= 2 )
   {
      
      // if (preamble->Item[0] == 0xFE && preamble->Item[1] == 0xFF) 
      if ( preamble[ 0 ] == 0xFE && preamble[ 1 ] == 0xFF )
      {
         Console::WriteLine( "The Unicode encoder is encoding in big-endian order." );
      }
      // else if (preamble->Item[0] == 0xFF && preamble->Item[1] == 0xFE) 
      else
      
      // else if (preamble->Item[0] == 0xFF && preamble->Item[1] == 0xFE) 
      if ( preamble[ 0 ] == 0xFF && preamble[ 1 ] == 0xFE )
      {
         Console::WriteLine( "The Unicode encoder is encoding in little-endian order." );
      }
   }
}

/*
This code produces the following output.

The Unicode encoder is encoding in little-endian order.

*/
using System;
using System.Text;

namespace GetPreambleExample
{
   class GetPreambleExampleClass
   {
      static void Main()
      {
         Encoding unicode = Encoding.Unicode;

         // Get the preamble for the Unicode encoder. 
         // In this case the preamble contains the byte order mark (BOM).
         byte[] preamble = unicode.GetPreamble();

         // Make sure a preamble was returned 
         // and is large enough to contain a BOM.
         if(preamble.Length >= 2)
         {
            if(preamble[0] == 0xFE && preamble[1] == 0xFF)
            {
               Console.WriteLine("The Unicode encoder is encoding in big-endian order.");
            }
            else if(preamble[0] == 0xFF && preamble[1] == 0xFE)
            {
               Console.WriteLine("The Unicode encoder is encoding in little-endian order.");
            }
         }
      }
   }
}

/*
This code produces the following output.

The Unicode encoder is encoding in little-endian order.

*/
Imports System.Text

Namespace GetPreambleExample
   Class GetPreambleExampleClass
      Shared Sub Main()
         Dim [unicode] As Encoding = Encoding.Unicode

         ' Get the preamble for the Unicode encoder. 
         ' In this case the preamble contains the byte order mark (BOM).
         Dim preamble As Byte() = [unicode].GetPreamble()

         ' Make sure a preamble was returned 
         ' and is large enough to contain a BOM.
         If preamble.Length >= 2 Then
            If preamble(0) = &HFE And preamble(1) = &HFF Then
               Console.WriteLine("The Unicode encoder is encoding in big-endian order.")
            Else
               If preamble(0) = &HFF And preamble(1) = &HFE Then
                  Console.WriteLine("The Unicode encoder is encoding in little-endian order.")
               End If
            End If
         End If
      End Sub
   End Class
End Namespace

'This code produces the following output.
'
'The Unicode encoder is encoding in little-endian order.
'

Comentários

Opcionalmente, o Encoding objeto fornece um preâmbulo que é uma matriz de bytes que pode ser prefixada para a sequência de bytes resultante do processo de codificação. Se o preâmbulo contiver uma marca de ordem de byte (em Unicode, ponto de código U + FEFF), ele ajudará o decodificador a determinar a ordem de bytes e o formato de transformação ou UTF.

A BOM (marca de ordem de byte) Unicode é serializada da seguinte maneira (em hexadecimal):

  • UTF-8: EF BB BF

  • Ordem de byte UTF-16 big endian: FE

  • Ordem de byte UTF-16 little endian: FF FE

  • UTF-32 big endian ordem de bytes: 00 00 FE FF

  • UTF-32 little endian ordem de byte: FF FE 00 00

Você deve usar a BOM, pois ela fornece quase certa identificação de uma codificação para arquivos que, de outra forma, perderam a referência ao Encoding objeto, por exemplo, dados da Web não marcados ou marcados incorretamente ou arquivos de texto aleatórios armazenados quando um negócio não tinha preocupações internacionais ou outros dados. Geralmente, problemas de usuário podem ser evitados se os dados forem marcados de forma consistente e correta, preferencialmente em UTF-8 ou UTF-16.

Para padrões que fornecem um tipo de codificação, uma BOM é um pouco redundante. No entanto, ele pode ser usado para ajudar um servidor a enviar o cabeçalho de codificação correto. Como alternativa, ele pode ser usado como um fallback, caso a codificação seja perdida.

Há algumas desvantagens em usar uma BOM. Por exemplo, saber como limitar os campos de banco de dados que usam uma BOM pode ser difícil. A concatenação de arquivos também pode ser um problema, por exemplo, quando os arquivos são mesclados de forma que um caractere desnecessário possa terminar no meio dos dados. No entanto, apesar das poucas desvantagens, o uso de uma BOM é altamente recomendável.

Para obter mais informações sobre a ordem de bytes e a marca de ordem de byte, consulte o padrão Unicode na Home Page Unicode.

Cuidado

Para garantir que os bytes codificados sejam decodificados corretamente, você deve prefixar bytes codificados com um preâmbulo. No entanto, a maioria das codificações não fornece um preâmbulo. Para garantir que os bytes codificados sejam decodificados corretamente, você deve usar uma codificação Unicode, ou seja,, UTF8Encoding UnicodeEncoding ou UTF32Encoding , com um preâmbulo.

Aplica-se a