Encoding.GetPreamble Encoding.GetPreamble Encoding.GetPreamble Encoding.GetPreamble Method

Définition

En cas de substitution dans une classe dérivée, retourne une séquence d'octets qui spécifie l'encodage utilisé.When overridden in a derived class, returns a sequence of bytes that specifies the encoding used.

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

Retours

Byte[]

Tableau d'octets contenant une séquence d'octets qui spécifie l'encodage utilisé.A byte array containing a sequence of bytes that specifies the encoding used.

- ou --or- Tableau d'octets de longueur nulle si aucun préambule n'est requis.A byte array of length zero, if a preamble is not required.

Exemples

L’exemple suivant détermine l’ordre d’octet de l’encodage selon le préambule.The following example determines the byte order of the encoding based on the preamble.

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

Remarques

Si vous le souhaitez, le Encoding objet fournit un préambule qui est un tableau d’octets qui peut porter comme préfixe à la séquence d’octets résultant du processus de codage.Optionally, the Encoding object provides a preamble that is an array of bytes that can be prefixed to the sequence of bytes resulting from the encoding process. Si le préambule contient une marque d’ordre d’octet (au format Unicode, le point de code U + FEFF), il aide le décodeur à déterminer l’ordre d’octet et que le format de transformation ou UTF.If the preamble contains a byte order mark (in Unicode, code point U+FEFF), it helps the decoder determine the byte order and the transformation format or UTF.

La marque d’ordre octet Unicode (BOM) est sérialisée comme suit (hexadécimal) :The Unicode byte order mark (BOM) is serialized as follows (in hexadecimal):

  • UTF-8 : EF BB BFUTF-8: EF BB BF

  • UTF-16 primauté des octets : FE FFUTF-16 big endian byte order: FE FF

  • Ordre de primauté des octets UTF-16 little : FF FEUTF-16 little endian byte order: FF FE

  • UTF-32 primauté des octets : 00 00 FE FFUTF-32 big endian byte order: 00 00 FE FF

  • Ordre de primauté des octets UTF-32 little : FF FE 00 00UTF-32 little endian byte order: FF FE 00 00

Vous devez utiliser la marque BOM, car il fournit une certaine identification d’un encodage pour fichiers qui autres ont perdu la référence à la Encoding objet, par exemple, sans balise ou incorrectement référencées données web ou des fichiers texte aléatoires stockés lorsqu’une entreprise n’ont pas avoir des intérêts internationaux ou autres données.You should use the BOM, because it provides nearly certain identification of an encoding for files that otherwise have lost reference to the Encoding object, for example, untagged or improperly tagged web data or random text files stored when a business did not have international concerns or other data. Souvent les problèmes d’utilisateur peuvent être évités si les données sont correctement et régulièrement référencées, de préférence dans UTF-8 ou UTF-16.Often user problems might be avoided if data is consistently and properly tagged, preferably in UTF-8 or UTF-16.

Des normes qui fournissent un type de codage, un BOM est quelque peu redondant.For standards that provide an encoding type, a BOM is somewhat redundant. Toutefois, il peut être utilisé pour aider à un serveur d’envoyer l’en-tête de codage correct.However, it can be used to help a server send the correct encoding header. Ou bien, il peut être utilisé comme solution de secours si l’encodage est perdu.Alternatively, it can be used as a fallback in case the encoding is otherwise lost.

Il existe certains inconvénients à l’utilisation d’une nomenclature.There are some disadvantages to using a BOM. Par exemple, savoir comment limiter les champs de base de données qui utilisent un BOM peut être difficile.For example, knowing how to limit the database fields that use a BOM can be difficult. Concaténation de fichiers peut être un problème également, par exemple, lorsque les fichiers sont fusionnés de telle façon un caractère inutile peut se retrouver au milieu des données.Concatenation of files can be a problem also, for example, when files are merged in such a way that an unnecessary character can end up in the middle of data. Malgré le peu d’inconvénients, cependant, l’utilisation d’une nomenclature est hautement recommandée.In spite of the few disadvantages, however, the use of a BOM is highly recommended.

Pour plus d’informations sur l’ordre d’octet et la marque d’ordre d’octet, consultez la norme Unicode dans le page d’accueil Unicode.For more information on byte order and the byte order mark, see The Unicode Standard at the Unicode home page.

Attention

Pour vous assurer que les octets encodés sont décodés correctement, vous devez précéder les octets encodés avec un préambule.To ensure that the encoded bytes are decoded properly, you should prefix encoded bytes with a preamble. Toutefois, la plupart des encodages ne fournissent pas de préambule.However, most encodings do not provide a preamble. Pour garantir que les octets encodés sont décodés correctement, vous devez utiliser un encodage Unicode, autrement dit, UTF8Encoding, UnicodeEncoding, ou UTF32Encoding, avec un préambule.To ensure that the encoded bytes are decoded properly, you should use a Unicode encoding, that is, UTF8Encoding, UnicodeEncoding, or UTF32Encoding, with a preamble.

S’applique à