Encoding.GetPreamble Metodo

Definizione

Spazio dei nomi:

System.Text

Assembly:

System.Runtime.dll

Origine:

Encoding.cs

Quando ne viene eseguito l'override in una classe derivata, restituisce una sequenza di byte che specifica la codifica usata.

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

Restituisce

Byte[]

Matrice di byte contenente una sequenza di byte che specifica la codifica usata.

-oppure-

Matrice di byte di lunghezza zero, se non è necessario alcun preambolo.

Esempio

Nell'esempio seguente viene determinato l'ordine dei byte della codifica in base al preambolo.

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.
'

Commenti

Facoltativamente, l' Encoding oggetto fornisce un preambolo che è una matrice di byte che può essere preceduta dalla sequenza di byte risultante dal processo di codifica. Se il preambolo contiene un byte order mark (in Unicode, punto di codice U + FEFF), consente al decodificatore di determinare l'ordine dei byte e il formato di trasformazione o UTF.

Il byte order mark Unicode (BOM) viene serializzato come indicato di seguito (in esadecimale):

• UTF-8: EF BB BF

• Ordine byte UTF-16 big endian: FE FF

• Codifica UTF-16 little endian byte order: FE FF

• UTF-32 big endian byte order: 00 00 FE FF

• UTF-32 little endian byte order: FF FE 00 00

È consigliabile utilizzare l'indicatore di ordine dei byte, in quanto fornisce una certa identificazione di una codifica per i file che altrimenti hanno perso il riferimento all' Encoding oggetto, ad esempio, i dati Web senza tag o con tag non corretti o file di testo casuale archiviati quando un'azienda non ha avuto problemi internazionali o altri dati. Spesso si potrebbero evitare problemi dell'utente se i dati vengono contrassegnati in modo coerente e corretto, preferibilmente in UTF-8 o UTF-16.

Per gli standard che forniscono un tipo di codifica, un BOM è piuttosto ridondante. Tuttavia, può essere utilizzato per consentire a un server di inviare l'intestazione di codifica corretta. In alternativa, può essere utilizzato come fallback in caso contrario, la codifica andrà persa.

L'utilizzo di un BOM presenta alcuni svantaggi. Ad esempio, sapere come limitare i campi del database che utilizzano un BOM può essere difficile. Anche la concatenazione di file può costituire un problema, ad esempio quando i file vengono uniti in modo tale che un carattere non necessario possa finire nel mezzo dei dati. Nonostante i pochi svantaggi, tuttavia, l'utilizzo di un BOM è altamente consigliato.

Per ulteriori informazioni sull'ordine dei byte e sulla byte order mark, vedere lo standard Unicode nella Home Page Unicode.

Attenzione

Per assicurarsi che i byte codificati vengano decodificati correttamente, è consigliabile anteporre i byte codificati a un preambolo. Tuttavia, la maggior parte delle codifiche non fornisce un preambolo. Per assicurarsi che i byte codificati vengano decodificati correttamente, è necessario usare una codifica Unicode, ovvero,, UTF8EncodingUnicodeEncoding o UTF32Encoding , con un preambolo.