Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais
Cette documentation est archivée et n’est pas conservée.

Encoding.GetMaxByteCount, méthode

En cas de substitution dans une classe dérivée, calcule le nombre maximal d'octets produits par l'encodage du nombre de caractères spécifié.

Espace de noms :  System.Text
Assembly :  mscorlib (dans mscorlib.dll)

public abstract int GetMaxByteCount(
	int charCount
)

Paramètres

charCount
Type : System.Int32
Nombre de caractères à encoder.

Valeur de retour

Type : System.Int32
Nombre maximal d'octets produits par l'encodage du nombre de caractères spécifié.

ExceptionCondition
ArgumentOutOfRangeException

charCount est inférieur à zéro.

EncoderFallbackException

Un secours s'est produit (consultez Encodage de caractères dans le .NET Framework pour obtenir une explication complète)

– et –

EncoderFallback a la valeur EncoderExceptionFallback.

Le paramètre charCount spécifie le nombre d'objets Char qui représentent les caractères Unicode à encoder, car le .NET Framework utilise en interne UTF-16 pour représenter les caractères Unicode. Par conséquent, la plupart des caractères Unicode peuvent être représentés par un objet Char, mais un caractère Unicode représenté par une paire de substitution, par exemple, nécessite deux objets Char.

Pour calculer la taille exacte de tableau requise par GetBytes pour stocker les octets obtenus, l'application doit utiliser GetByteCount. Pour calculer la taille de tableau maximale, elle doit utiliser GetMaxByteCount. En règle générale, la méthode GetByteCount vous permet d'utiliser moins de mémoire, alors que la méthode GetMaxByteCount s'exécute plus vite.

GetMaxByteCount extrait un nombre pour le cas le plus défavorable, y compris le cas le plus défavorable pour le EncoderFallback actuellement sélectionné. Si un secours est choisi avec une chaîne potentiellement grande, GetMaxByteCount extrait de grandes valeurs, en particulier dans les cas où le cas le plus improbable pour l'encodage implique des modes de commutation pour chaque caractère. Par exemple, cela peut arriver pour l'ISO-2022-JP. Pour plus d'informations, consultez l'entrée de blog What's with Encoding.GetMaxByteCount() and Encoding.GetMaxCharCount()?" (http://blogs.msdn.com/shawnste/archive/2005/03/02/383903.aspx).

Dans la plupart des cas, cette méthode extrait des valeurs raisonnables pour les chaînes de petite taille. Pour les grandes chaînes, vous aurez peut-être à choisir entre l'utilisation de mémoires tampons de grande taille et l'interception d'erreurs dans les rares cas où une taille de mémoire tampon plus raisonnable est trop petite. Vous pouvez également souhaiter considérer une approche différente à l'aide de GetByteCount ou Encoder.Convert.

Lors de l'utilisation de GetMaxByteCount, votre application doit allouer la mémoire tampon de sortie selon la taille maximale de la mémoire tampon d'entrée. Si une contrainte de taille s'applique à la mémoire tampon de sortie, l'application peut utiliser la méthode Convert.

Notez que GetMaxByteCount prend en compte les substituts potentiels restants d'une opération de décodeur antérieure. À cause du décodeur, le passage d'une valeur de 1 à la méthode extrait 2 pour un encodage sur un octet, comme l'ASCII. Votre application doit utiliser la propriété IsSingleByte si ces informations sont nécessaires.

RemarqueRemarque

GetMaxByteCount(N) n'a pas nécessairement la même valeur que N* GetMaxByteCount(1).

Remarques à l'attention des implémenteurs

Toutes les implémentations Encoding doivent garantir qu'aucune exception de débordement de capacité de la mémoire tampon ne se produit si la taille de chaque mémoire tampon est déterminée en fonction des résultats des calculs de cette méthode.

L'exemple suivant détermine le nombre d'octets requis pour encoder un tableau de caractères, encode les caractères, puis affiche les octets obtenus.


using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

      // The characters to encode:
      //    Latin Small Letter Z (U+007A)
      //    Latin Small Letter A (U+0061)
      //    Combining Breve (U+0306)
      //    Latin Small Letter AE With Acute (U+01FD)
      //    Greek Small Letter Beta (U+03B2)
      //    a high-surrogate value (U+D8FF)
      //    a low-surrogate value (U+DCFF)
      char[] myChars = new char[] { 'z', 'a', '\u0306', '\u01FD', '\u03B2', '\uD8FF', '\uDCFF' };

      // Get different encodings.
      Encoding  u7    = Encoding.UTF7;
      Encoding  u8    = Encoding.UTF8;
      Encoding  u16LE = Encoding.Unicode;
      Encoding  u16BE = Encoding.BigEndianUnicode;
      Encoding  u32   = Encoding.UTF32;

      // Encode the entire array, and print out the counts and the resulting bytes.
      PrintCountsAndBytes( myChars, u7 );
      PrintCountsAndBytes( myChars, u8 );
      PrintCountsAndBytes( myChars, u16LE );
      PrintCountsAndBytes( myChars, u16BE );
      PrintCountsAndBytes( myChars, u32 );

   }


   public static void PrintCountsAndBytes( char[] chars, Encoding enc )  {

      // Display the name of the encoding used.
      Console.Write( "{0,-30} :", enc.ToString() );

      // Display the exact byte count.
      int iBC  = enc.GetByteCount( chars );
      Console.Write( " {0,-3}", iBC );

      // Display the maximum byte count.
      int iMBC = enc.GetMaxByteCount( chars.Length );
      Console.Write( " {0,-3} :", iMBC );

      // Encode the array of chars.
      byte[] bytes = enc.GetBytes( chars );

      // Display all the encoded bytes.
      PrintHexBytes( bytes );

   }


   public static void PrintHexBytes( byte[] bytes )  {

      if (( bytes == null ) || ( bytes.Length == 0 ))
         Console.WriteLine( "<none>" );
      else  {
         for ( int i = 0; i < bytes.Length; i++ )
            Console.Write( "{0:X2} ", bytes[i] );
         Console.WriteLine();
      }

   }

}


/* 
This code produces the following output.

System.Text.UTF7Encoding       : 18  23  :7A 61 2B 41 77 59 42 2F 51 4F 79 32 50 2F 63 2F 77 2D
System.Text.UTF8Encoding       : 12  24  :7A 61 CC 86 C7 BD CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding    : 14  16  :7A 00 61 00 06 03 FD 01 B2 03 FF D8 FF DC
System.Text.UnicodeEncoding    : 14  16  :00 7A 00 61 03 06 01 FD 03 B2 D8 FF DC FF
System.Text.UTF32Encoding      : 24  32  :7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00 FF FC 04 00

*/



.NET Framework

Pris en charge dans : 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Pris en charge dans :

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
Afficher: