Encoding.GetMaxByteCount(Int32) Encoding.GetMaxByteCount(Int32) Encoding.GetMaxByteCount(Int32) Encoding.GetMaxByteCount(Int32) Method

Definición

Cuando se reemplaza en una clase derivada, calcula el número máximo de bytes que se generan al codificar el número de caracteres especificado.When overridden in a derived class, calculates the maximum number of bytes produced by encoding the specified number of characters.

public:
 abstract int GetMaxByteCount(int charCount);
public abstract int GetMaxByteCount (int charCount);
abstract member GetMaxByteCount : int -> int
Public MustOverride Function GetMaxByteCount (charCount As Integer) As Integer

Parámetros

charCount
Int32 Int32 Int32 Int32

Número de caracteres que se van a codificar.The number of characters to encode.

Devoluciones

Número máximo de bytes generados al codificar el número de caracteres especificado.The maximum number of bytes produced by encoding the specified number of characters.

Excepciones

Se ha producido una acción de reserva (vea Codificación de caracteres de .NET para obtener una explicación completa)A fallback occurred (see Character Encoding in .NET for complete explanation) - y --and- El valor de EncoderFallback está establecido en EncoderExceptionFallback.EncoderFallback is set to EncoderExceptionFallback.

Ejemplos

El ejemplo siguiente determina el número de bytes necesarios para codificar una matriz de caracteres, codifica los caracteres y muestra los bytes resultantes.The following example determines the number of bytes required to encode a character array, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( array<Char>^chars, Encoding^ enc );
void PrintHexBytes( array<Byte>^bytes );
int 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)
   array<Char>^myChars = gcnew array<Char>{
      L'z','a',L'\u0306',L'\u01FD',L'\u03B2',L'\xD8FF',L'\xDCFF'
   };
   
   // 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 );
}

void PrintCountsAndBytes( array<Char>^chars, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-30} :", enc );
   
   // 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.
   array<Byte>^bytes = enc->GetBytes( chars );
   
   // Display all the encoded bytes.
   PrintHexBytes( bytes );
}

void PrintHexBytes( array<Byte>^bytes )
{
   if ( (bytes == nullptr) || (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

*/
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

*/

Imports System
Imports System.Text
Imports Microsoft.VisualBasic

Public Class SamplesEncoding   

   Public Shared Sub 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)
      Dim myChars() As Char = {"z"c, "a"c, ChrW(&H0306), ChrW(&H01FD), ChrW(&H03B2), ChrW(&HD8FF), ChrW(&HDCFF)}
 

      ' Get different encodings.
      Dim u7 As Encoding = Encoding.UTF7
      Dim u8 As Encoding = Encoding.UTF8
      Dim u16LE As Encoding = Encoding.Unicode
      Dim u16BE As Encoding = Encoding.BigEndianUnicode
      Dim u32 As Encoding = 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)

   End Sub 'Main


   Public Shared Sub PrintCountsAndBytes(chars() As Char, enc As Encoding)

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

      ' Display the exact byte count.
      Dim iBC As Integer = enc.GetByteCount(chars)
      Console.Write(" {0,-3}", iBC)

      ' Display the maximum byte count.
      Dim iMBC As Integer = enc.GetMaxByteCount(chars.Length)
      Console.Write(" {0,-3} :", iMBC)

      ' Encode the array of chars.
      Dim bytes As Byte() = enc.GetBytes(chars)

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub 'PrintCountsAndBytes


   Public Shared Sub PrintHexBytes(bytes() As Byte)

      If bytes Is Nothing OrElse bytes.Length = 0 Then
         Console.WriteLine("<none>")
      Else
         Dim i As Integer
         For i = 0 To bytes.Length - 1
            Console.Write("{0:X2} ", bytes(i))
         Next i
         Console.WriteLine()
      End If

   End Sub 'PrintHexBytes 

End Class 'SamplesEncoding


'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

Comentarios

El charCount parámetro especifica el número de Char objetos que representan los caracteres Unicode que se va a codificar, porque .NET utiliza internamente UTF-16 para representar caracteres Unicode.The charCount parameter actually specifies the number of Char objects that represent the Unicode characters to encode, because .NET internally uses UTF-16 to represent Unicode characters. Por lo tanto, se puede representar la mayoría de los caracteres Unicode por uno Char objeto, pero un carácter Unicode representado por un par suplente, por ejemplo, se requieren dos Char objetos.Consequently, most Unicode characters can be represented by one Char object, but a Unicode character represented by a surrogate pair, for example, requires two Char objects.

Para calcular el tamaño exacto de matriz requerido GetBytes para almacenar los bytes resultantes, debe usar el GetByteCount método.To calculate the exact array size required by GetBytes to store the resulting bytes, you should use the GetByteCount method. Para calcular el tamaño máximo de la matriz, use el GetMaxByteCount método.To calculate the maximum array size, use the GetMaxByteCount method. El GetByteCount método generalmente permite asignar menos memoria, mientras que el GetMaxByteCount método generalmente se ejecuta con mayor rapidez.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

GetMaxByteCount Recupera un número de caso peor, incluyendo el peor de los casos para el que se han seleccionado actualmente EncoderFallback.GetMaxByteCount retrieves a worst-case number, including the worst case for the currently selected EncoderFallback. Si se elige una acción de reserva con una cadena potencialmente grande, GetMaxByteCount recupera valores grandes, especialmente en casos donde el peor caso para la codificación implica cambiar los modos de cada carácter.If a fallback is chosen with a potentially large string, GetMaxByteCount retrieves large values, particularly in cases where the worst case for the encoding involves switching modes for every character. Por ejemplo, esto puede ocurrir para ISO-2022-JP.For example, this can happen for ISO-2022-JP. Para obtener más información, consulte la entrada de blog "What ' s con Encoding.GetMaxByteCount y Encoding.GetMaxCharCount ()?"For more information, see the blog entry "What's with Encoding.GetMaxByteCount() and Encoding.GetMaxCharCount()?" (http://blogs.msdn.com/shawnste/archive/2005/03/02/383903.aspx).(http://blogs.msdn.com/shawnste/archive/2005/03/02/383903.aspx).

En la mayoría de los casos, este método recupera valores razonables para cadenas pequeñas.In most cases, this method retrieves reasonable values for small strings. Cadenas de gran tamaño, tendrá que elegir entre usar búferes muy grandes y detectar errores en el extraño caso cuando un búfer más razonable es demasiado pequeño.For large strings, you might have to choose between using very large buffers and catching errors in the rare case when a more reasonable buffer is too small. También puede tener en cuenta un enfoque diferente utilizando GetByteCount o Encoder.Convert.You might also want to consider a different approach using GetByteCount or Encoder.Convert.

Cuando se usa GetMaxByteCount, debe asignar el búfer de salida en función del tamaño máximo del búfer de entrada.When using GetMaxByteCount, you should allocate the output buffer based on the maximum size of the input buffer. Si el búfer de salida está restringido en tamaño, puede usar el Convert método.If the output buffer is constrained in size, you might use the Convert method.

Tenga en cuenta que GetMaxByteCount considera los suplentes potenciales de una operación del descodificador anterior.Note that GetMaxByteCount considers potential leftover surrogates from a previous decoder operation. Debido al descodificador, pasando el valor 1 para el método recupera 2 para una codificación de byte único, como ASCII.Because of the decoder, passing a value of 1 to the method retrieves 2 for a single-byte encoding, such as ASCII. Debe usar el IsSingleByte propiedad si esta información es necesaria.You should use the IsSingleByte property if this information is necessary.

Nota

GetMaxByteCount(N) no es necesariamente el mismo valor que N* GetMaxByteCount(1).GetMaxByteCount(N) is not necessarily the same value as N* GetMaxByteCount(1).

Notas a los desarrolladores de herederos

Todos los Encoding implementaciones deben garantizar que ninguna excepción de desbordamiento de búfer se producirá si los búferes según los resultados de cálculos de este método.All Encoding implementations must guarantee that no buffer overflow exceptions occur if buffers are sized according to the results of this method's calculations.

Se aplica a

Consulte también: