Encoding.GetByteCount Método

Definição

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters.

Sobrecargas

GetByteCount(String, Int32, Int32)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres da cadeia de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified string.

GetByteCount(Char[], Int32, Int32)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres da matriz de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified character array.

GetByteCount(Char*, Int32)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres começando no ponteiro de caracteres especificado.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.

GetByteCount(String)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de caracteres na cadeia de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified string.

GetByteCount(ReadOnlySpan<Char>)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação dos caracteres no intervalo de caracteres especificado.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified character span.

GetByteCount(Char[])

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de todos os caracteres na matriz de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding all the characters in the specified character array.

GetByteCount(String, Int32, Int32)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres da cadeia de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified string.

public:
 int GetByteCount(System::String ^ s, int index, int count);
public int GetByteCount (string s, int index, int count);
member this.GetByteCount : string * int * int -> int
Public Function GetByteCount (s As String, index As Integer, count As Integer) As Integer

Parâmetros

s
String

A cadeia de caracteres que contém o conjunto de caracteres a ser codificado.The string containing the set of characters to encode.

index
Int32

O índice do primeiro caractere a ser codificado.The index of the first character to encode.

count
Int32

O número de caracteres a ser codificado.The number of characters to encode.

Retornos

O número de bytes produzidos pela codificação da cadeia de caracteres.The number of bytes produced by encoding the string.

Exemplos

O exemplo a seguir determina o número de bytes necessários para codificar três caracteres de uma matriz de caracteres, codifica os caracteres e exibe os bytes resultantes.The following example determines the number of bytes required to encode three characters from a character array, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( array<Char>^chars, int index, int count, 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',L'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 three characters starting at index 4, and print out the counts and the resulting bytes.
   PrintCountsAndBytes( myChars, 4, 3, u7 );
   PrintCountsAndBytes( myChars, 4, 3, u8 );
   PrintCountsAndBytes( myChars, 4, 3, u16LE );
   PrintCountsAndBytes( myChars, 4, 3, u16BE );
   PrintCountsAndBytes( myChars, 4, 3, u32 );
}

void PrintCountsAndBytes( array<Char>^chars, int index, int count, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-30} :", enc );
   
   // Display the exact byte count.
   int iBC = enc->GetByteCount( chars, index, count );
   Console::Write( " {0,-3}", iBC );
   
   // Display the maximum byte count.
   int iMBC = enc->GetMaxByteCount( count );
   Console::Write( " {0,-3} :", iMBC );
   
   // Encode the array of chars.
   array<Byte>^bytes = enc->GetBytes( chars, index, count );
   
   // The following is an alternative way to encode the array of chars:
   // byte[] bytes = new byte[iBC];
   // enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) );
   // 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       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
System.Text.UTF32Encoding      : 8   16  :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 three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes( myChars, 4, 3, u7 );
      PrintCountsAndBytes( myChars, 4, 3, u8 );
      PrintCountsAndBytes( myChars, 4, 3, u16LE );
      PrintCountsAndBytes( myChars, 4, 3, u16BE );
      PrintCountsAndBytes( myChars, 4, 3, u32 );
   }

   public static void PrintCountsAndBytes( char[] chars, int index, int count, 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, index, count );
      Console.Write( " {0,-3}", iBC );

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

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

      // The following is an alternative way to encode the array of chars:
      // byte[] bytes = new byte[iBC];
      // enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) );

      // 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       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
System.Text.UTF32Encoding      : 8   16  :B2 03 00 00 FF FC 04 00

*/

Imports System.Text

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 three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes(myChars, 4, 3, u7)
      PrintCountsAndBytes(myChars, 4, 3, u8)
      PrintCountsAndBytes(myChars, 4, 3, u16LE)
      PrintCountsAndBytes(myChars, 4, 3, u16BE)
      PrintCountsAndBytes(myChars, 4, 3, u32)

   End Sub


   Public Shared Sub PrintCountsAndBytes(chars() As Char, index As Integer, count As Integer, 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, index, count)
      Console.Write(" {0,-3}", iBC)

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

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

      ' The following is an alternative way to encode the array of chars:
      ' NOTE: In VB.NET, arrays contain one extra element by default.
      '       The following line creates the array with the exact number of elements required.
      ' Dim bytes(iBC - 1) As Byte
      ' enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) )

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   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

End Class


'This code produces the following output.
'
'System.Text.UTF7Encoding       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
'System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
'System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
'System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
'System.Text.UTF32Encoding      : 8   16  :B2 03 00 00 FF FC 04 00

Comentários

Para calcular o tamanho exato da matriz exigido pelo GetBytes para armazenar os bytes resultantes, chame o método GetByteCount.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Para calcular o tamanho máximo da matriz, chame o método GetMaxByteCount.To calculate the maximum array size, call the GetMaxByteCount method. O método GetByteCount geralmente permite a alocação de menos memória, enquanto o método GetMaxByteCount geralmente é executado mais rapidamente.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

O método GetByteCount determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode e o método GetBytes executa a codificação real.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. O método GetBytes espera conversões discretas, ao contrário do método Encoder.GetBytes, que lida com várias conversões em um único fluxo de entrada.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Há suporte para várias versões do GetByteCount e GetBytes.Several versions of GetByteCount and GetBytes are supported. A seguir estão algumas considerações de programação para o uso desses métodos:The following are some programming considerations for use of these methods:

  • Seu aplicativo pode precisar codificar muitos caracteres de entrada em uma página de código e processar os caracteres usando várias chamadas.Your app might need to encode many input characters to a code page and process the characters using multiple calls. Nesse caso, é provável que você precise manter o estado entre as chamadas, levando em conta o estado que é persistido pelo objeto de Encoder que está sendo usado.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Se o seu aplicativo lida com entradas de cadeia de caracteres, a versão de cadeia de caracteres do GetBytes é recomendada.If your app handles string inputs, the string version of GetBytes is recommended.

  • A versão de buffer de caracteres Unicode do GetBytes(Char*, Int32, Byte*, Int32) permite algumas técnicas rápidas, especialmente com várias chamadas usando o objeto Encoder ou inserindo em buffers existentes.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. No entanto, lembre-se de que essa versão do método às vezes não é segura, já que os ponteiros são necessários.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Se seu aplicativo precisar converter uma grande quantidade de dados, ele deverá reutilizar o buffer de saída.If your app must convert a large amount of data, it should reuse the output buffer. Nesse caso, a versão GetBytes que dá suporte a matrizes de bytes é a melhor opção.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Considere usar o método Encoder.Convert em vez de GetByteCount.Consider using the Encoder.Convert method instead of GetByteCount. O método de conversão converte o máximo de dados possível e gera uma exceção se o buffer de saída for muito pequeno.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Para a codificação contínua de um fluxo, esse método geralmente é a melhor opção.For continuous encoding of a stream, this method is often the best choice.

GetByteCount(Char[], Int32, Int32)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres da matriz de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified character array.

public:
 abstract int GetByteCount(cli::array <char> ^ chars, int index, int count);
public abstract int GetByteCount (char[] chars, int index, int count);
abstract member GetByteCount : char[] * int * int -> int
Public MustOverride Function GetByteCount (chars As Char(), index As Integer, count As Integer) As Integer

Parâmetros

chars
Char[]

A matriz de caracteres que contém o conjunto de caracteres a serem codificados.The character array containing the set of characters to encode.

index
Int32

O índice do primeiro caractere a ser codificado.The index of the first character to encode.

count
Int32

O número de caracteres a ser codificado.The number of characters to encode.

Retornos

O número de bytes produzidos por codificação de caracteres especificados.The number of bytes produced by encoding the specified characters.

Exceções

chars é null.chars is null.

index ou count é menor que zero.index or count is less than zero.

- ou --or-

index e count não denotam um intervalo válido em chars.index and count do not denote a valid range in chars.

Ocorreu um fallback (saiba mais em Codificação de caracteres no .NET)A fallback occurred (for more information, see Character Encoding in .NET)

-e--and-

EncoderFallback é definido como EncoderExceptionFallback.EncoderFallback is set to EncoderExceptionFallback.

Exemplos

O exemplo a seguir determina o número de bytes necessários para codificar três caracteres de uma matriz de caracteres, codifica os caracteres e exibe os bytes resultantes.The following example determines the number of bytes required to encode three characters from a character array, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( array<Char>^chars, int index, int count, 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',L'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 three characters starting at index 4, and print out the counts and the resulting bytes.
   PrintCountsAndBytes( myChars, 4, 3, u7 );
   PrintCountsAndBytes( myChars, 4, 3, u8 );
   PrintCountsAndBytes( myChars, 4, 3, u16LE );
   PrintCountsAndBytes( myChars, 4, 3, u16BE );
   PrintCountsAndBytes( myChars, 4, 3, u32 );
}

void PrintCountsAndBytes( array<Char>^chars, int index, int count, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-30} :", enc );
   
   // Display the exact byte count.
   int iBC = enc->GetByteCount( chars, index, count );
   Console::Write( " {0,-3}", iBC );
   
   // Display the maximum byte count.
   int iMBC = enc->GetMaxByteCount( count );
   Console::Write( " {0,-3} :", iMBC );
   
   // Encode the array of chars.
   array<Byte>^bytes = enc->GetBytes( chars, index, count );
   
   // The following is an alternative way to encode the array of chars:
   // byte[] bytes = new byte[iBC];
   // enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) );
   // 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       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
System.Text.UTF32Encoding      : 8   16  :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 three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes( myChars, 4, 3, u7 );
      PrintCountsAndBytes( myChars, 4, 3, u8 );
      PrintCountsAndBytes( myChars, 4, 3, u16LE );
      PrintCountsAndBytes( myChars, 4, 3, u16BE );
      PrintCountsAndBytes( myChars, 4, 3, u32 );
   }

   public static void PrintCountsAndBytes( char[] chars, int index, int count, 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, index, count );
      Console.Write( " {0,-3}", iBC );

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

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

      // The following is an alternative way to encode the array of chars:
      // byte[] bytes = new byte[iBC];
      // enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) );

      // 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       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
System.Text.UTF32Encoding      : 8   16  :B2 03 00 00 FF FC 04 00

*/

Imports System.Text

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 three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes(myChars, 4, 3, u7)
      PrintCountsAndBytes(myChars, 4, 3, u8)
      PrintCountsAndBytes(myChars, 4, 3, u16LE)
      PrintCountsAndBytes(myChars, 4, 3, u16BE)
      PrintCountsAndBytes(myChars, 4, 3, u32)

   End Sub


   Public Shared Sub PrintCountsAndBytes(chars() As Char, index As Integer, count As Integer, 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, index, count)
      Console.Write(" {0,-3}", iBC)

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

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

      ' The following is an alternative way to encode the array of chars:
      ' NOTE: In VB.NET, arrays contain one extra element by default.
      '       The following line creates the array with the exact number of elements required.
      ' Dim bytes(iBC - 1) As Byte
      ' enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) )

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   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

End Class


'This code produces the following output.
'
'System.Text.UTF7Encoding       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
'System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
'System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
'System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
'System.Text.UTF32Encoding      : 8   16  :B2 03 00 00 FF FC 04 00

Comentários

Para calcular o tamanho exato da matriz exigido pelo GetBytes para armazenar os bytes resultantes, chame o método GetByteCount.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Para calcular o tamanho máximo da matriz, chame o método GetMaxByteCount.To calculate the maximum array size, call the GetMaxByteCount method. O método GetByteCount geralmente permite a alocação de menos memória, enquanto o método GetMaxByteCount geralmente é executado mais rapidamente.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

O método GetByteCount determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode e o método GetBytes executa a codificação real.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. O método GetBytes espera conversões discretas, ao contrário do método Encoder.GetBytes, que lida com várias conversões em um único fluxo de entrada.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Há suporte para várias versões do GetByteCount e GetBytes.Several versions of GetByteCount and GetBytes are supported. A seguir estão algumas considerações de programação para o uso desses métodos:The following are some programming considerations for use of these methods:

  • Seu aplicativo pode precisar codificar muitos caracteres de entrada em uma página de código e processar os caracteres usando várias chamadas.Your app might need to encode many input characters to a code page and process the characters using multiple calls. Nesse caso, é provável que você precise manter o estado entre as chamadas, levando em conta o estado que é persistido pelo objeto de Encoder que está sendo usado.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Se o seu aplicativo lida com entradas de cadeia de caracteres, a versão de cadeia de caracteres do GetBytes é recomendada.If your app handles string inputs, the string version of GetBytes is recommended.

  • A versão de buffer de caracteres Unicode do GetBytes(Char*, Int32, Byte*, Int32) permite algumas técnicas rápidas, especialmente com várias chamadas usando o objeto Encoder ou inserindo em buffers existentes.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. No entanto, lembre-se de que essa versão do método às vezes não é segura, já que os ponteiros são necessários.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Se seu aplicativo precisar converter uma grande quantidade de dados, ele deverá reutilizar o buffer de saída.If your app must convert a large amount of data, it should reuse the output buffer. Nesse caso, a versão GetBytes que dá suporte a matrizes de bytes é a melhor opção.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Considere usar o método Encoder.Convert em vez de GetByteCount.Consider using the Encoder.Convert method instead of GetByteCount. O método de conversão converte o máximo de dados possível e gera uma exceção se o buffer de saída for muito pequeno.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Para a codificação contínua de um fluxo, esse método geralmente é a melhor opção.For continuous encoding of a stream, this method is often the best choice.

Veja também

GetByteCount(Char*, Int32)

Importante

Esta API não está em conformidade com CLS.

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres começando no ponteiro de caracteres especificado.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.

public:
 virtual int GetByteCount(char* chars, int count);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public virtual int GetByteCount (char* chars, int count);
[System.CLSCompliant(false)]
public virtual int GetByteCount (char* chars, int count);
[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetByteCount (char* chars, int count);
[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(false)]
[System.Security.SecurityCritical]
public virtual int GetByteCount (char* chars, int count);
abstract member GetByteCount : nativeptr<char> * int -> int
override this.GetByteCount : nativeptr<char> * int -> int

Parâmetros

chars
Char*

Um ponteiro para o primeiro caractere a ser codificado.A pointer to the first character to encode.

count
Int32

O número de caracteres a ser codificado.The number of characters to encode.

Retornos

O número de bytes produzidos por codificação de caracteres especificados.The number of bytes produced by encoding the specified characters.

Atributos

Exceções

chars é null.chars is null.

count é menor que zero.count is less than zero.

Ocorreu um fallback (saiba mais em Codificação de caracteres no .NET)A fallback occurred (for more information, see Character Encoding in .NET)

-e--and-

EncoderFallback é definido como EncoderExceptionFallback.EncoderFallback is set to EncoderExceptionFallback.

Comentários

Para calcular o tamanho exato da matriz que GetBytes exige para armazenar os bytes resultantes, você deve chamar o método GetByteCount.To calculate the exact array size that GetBytes requires to store the resulting bytes, you should call the GetByteCount method. Para calcular o tamanho máximo da matriz, chame o método GetMaxByteCount.To calculate the maximum array size, call the GetMaxByteCount method. O método GetByteCount geralmente permite a alocação de menos memória, enquanto o método GetMaxByteCount geralmente é executado mais rapidamente.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

O método GetByteCount(Char*, Int32) determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode e o método GetBytes(Char*, Int32, Byte*, Int32) executa a codificação real.The GetByteCount(Char*, Int32) method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes(Char*, Int32, Byte*, Int32) method performs the actual encoding. O método GetBytes espera conversões discretas, ao contrário do método Encoder.GetBytes, que lida com várias conversões em um único fluxo de entrada.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Há suporte para várias versões do GetByteCount e GetBytes.Several versions of GetByteCount and GetBytes are supported. A seguir, algumas considerações sobre o uso desses métodos:The following are some considerations for using these methods:

  • Seu aplicativo pode precisar codificar muitos caracteres de entrada em uma página de código e processar os caracteres usando várias chamadas.Your app may need to encode many input characters to a code page and process the characters using multiple calls. Nesse caso, é provável que você precise manter o estado entre as chamadas, levando em conta o estado que é persistido pelo objeto de Encoder que está sendo usado.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Se seu aplicativo lida com entradas de cadeia de caracteres, você deve usar a versão de cadeia de caracteres do método GetBytes.If your app handles string inputs, you should use the string version of the GetBytes method.

  • A versão de buffer de caracteres Unicode do GetBytes permite algumas técnicas rápidas, especialmente com várias chamadas usando o objeto Encoder ou inserindo em buffers existentes.The Unicode character buffer version of GetBytes allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. No entanto, lembre-se de que essa versão do método às vezes não é segura, já que os ponteiros são necessários.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Se seu aplicativo precisar converter uma grande quantidade de dados, ele deverá reutilizar o buffer de saída.If your app must convert a large amount of data, it should reuse the output buffer. Nesse caso, a versão GetBytes que dá suporte a matrizes de bytes é a melhor opção.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Considere usar o método Encoder.Convert em vez de GetByteCount.Consider using the Encoder.Convert method instead of GetByteCount. O método de conversão converte o máximo de dados possível e gera uma exceção se o buffer de saída for muito pequeno.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Para a codificação contínua de um fluxo, esse método geralmente é a melhor opção.For continuous encoding of a stream, this method is often the best choice.

Veja também

GetByteCount(String)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de caracteres na cadeia de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified string.

public:
 virtual int GetByteCount(System::String ^ s);
public virtual int GetByteCount (string s);
abstract member GetByteCount : string -> int
override this.GetByteCount : string -> int
Public Overridable Function GetByteCount (s As String) As Integer

Parâmetros

s
String

A cadeia de caracteres que contém o conjunto de caracteres a ser codificado.The string containing the set of characters to encode.

Retornos

O número de bytes produzidos por codificação de caracteres especificados.The number of bytes produced by encoding the specified characters.

Exceções

s é null.s is null.

Ocorreu um fallback (saiba mais em Codificação de caracteres no .NET)A fallback occurred (for more information, see Character Encoding in .NET)

-e--and-

EncoderFallback é definido como EncoderExceptionFallback.EncoderFallback is set to EncoderExceptionFallback.

Exemplos

O exemplo a seguir determina o número de bytes necessários para codificar uma cadeia de caracteres ou um intervalo na cadeia de caracteres, codifica os caracteres e exibe os bytes resultantes.The following example determines the number of bytes required to encode a string or a range in the string, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( String^ s, Encoding^ enc );
void PrintCountsAndBytes( String^ s, int index, int count, 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)
   String^ myStr = L"za\u0306\u01FD\u03B2\xD8FF\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 string, and print out the counts and the resulting bytes.
   Console::WriteLine( "Encoding the entire string:" );
   PrintCountsAndBytes( myStr, u7 );
   PrintCountsAndBytes( myStr, u8 );
   PrintCountsAndBytes( myStr, u16LE );
   PrintCountsAndBytes( myStr, u16BE );
   PrintCountsAndBytes( myStr, u32 );
   Console::WriteLine();
   
   // Encode three characters starting at index 4, and print out the counts and the resulting bytes.
   Console::WriteLine( "Encoding the characters from index 4 through 6:" );
   PrintCountsAndBytes( myStr, 4, 3, u7 );
   PrintCountsAndBytes( myStr, 4, 3, u8 );
   PrintCountsAndBytes( myStr, 4, 3, u16LE );
   PrintCountsAndBytes( myStr, 4, 3, u16BE );
   PrintCountsAndBytes( myStr, 4, 3, u32 );
}

void PrintCountsAndBytes( String^ s, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-30} :", enc );
   
   // Display the exact byte count.
   int iBC = enc->GetByteCount( s );
   Console::Write( " {0,-3}", iBC );
   
   // Display the maximum byte count.
   int iMBC = enc->GetMaxByteCount( s->Length );
   Console::Write( " {0,-3} :", iMBC );
   
   // Encode the entire string.
   array<Byte>^bytes = enc->GetBytes( s );
   
   // Display all the encoded bytes.
   PrintHexBytes( bytes );
}

void PrintCountsAndBytes( String^ s, int index, int count, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-30} :", enc );
   
   // Display the exact byte count.
   int iBC = enc->GetByteCount( s->ToCharArray(), index, count );
   Console::Write( " {0,-3}", iBC );
   
   // Display the maximum byte count.
   int iMBC = enc->GetMaxByteCount( count );
   Console::Write( " {0,-3} :", iMBC );
   
   // Encode a range of characters in the string.
   array<Byte>^bytes = gcnew array<Byte>(iBC);
   enc->GetBytes( s, index, count, bytes, bytes->GetLowerBound( 0 ) );
   
   // 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.

Encoding the entire string:
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

Encoding the characters from index 4 through 6:
System.Text.UTF7Encoding       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
System.Text.UTF32Encoding      : 8   16  :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)
      String myStr = "za\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 string, and print out the counts and the resulting bytes.
      Console.WriteLine( "Encoding the entire string:" );
      PrintCountsAndBytes( myStr, u7 );
      PrintCountsAndBytes( myStr, u8 );
      PrintCountsAndBytes( myStr, u16LE );
      PrintCountsAndBytes( myStr, u16BE );
      PrintCountsAndBytes( myStr, u32 );

      Console.WriteLine();

      // Encode three characters starting at index 4, and print out the counts and the resulting bytes.
      Console.WriteLine( "Encoding the characters from index 4 through 6:" );
      PrintCountsAndBytes( myStr, 4, 3, u7 );
      PrintCountsAndBytes( myStr, 4, 3, u8 );
      PrintCountsAndBytes( myStr, 4, 3, u16LE );
      PrintCountsAndBytes( myStr, 4, 3, u16BE );
      PrintCountsAndBytes( myStr, 4, 3, u32 );
   }

   public static void PrintCountsAndBytes( String s, Encoding enc )  {

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

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

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

      // Encode the entire string.
      byte[] bytes = enc.GetBytes( s );

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

   public static void PrintCountsAndBytes( String s, int index, int count, Encoding enc )  {

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

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

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

      // Encode a range of characters in the string.
      byte[] bytes = new byte[iBC];
      enc.GetBytes( s, index, count, bytes, bytes.GetLowerBound(0) );

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

Encoding the entire string:
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

Encoding the characters from index 4 through 6:
System.Text.UTF7Encoding       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
System.Text.UTF32Encoding      : 8   16  :B2 03 00 00 FF FC 04 00

*/

Imports System.Text

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 myStr As String = "za" & 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 string, and print out the counts and the resulting bytes.
      Console.WriteLine("Encoding the entire string:")
      PrintCountsAndBytes(myStr, u7)
      PrintCountsAndBytes(myStr, u8)
      PrintCountsAndBytes(myStr, u16LE)
      PrintCountsAndBytes(myStr, u16BE)
      PrintCountsAndBytes(myStr, u32)

      Console.WriteLine()

      ' Encode three characters starting at index 4, and print out the counts and the resulting bytes.
      Console.WriteLine("Encoding the characters from index 4 through 6:")
      PrintCountsAndBytes(myStr, 4, 3, u7)
      PrintCountsAndBytes(myStr, 4, 3, u8)
      PrintCountsAndBytes(myStr, 4, 3, u16LE)
      PrintCountsAndBytes(myStr, 4, 3, u16BE)
      PrintCountsAndBytes(myStr, 4, 3, u32)

   End Sub


   Overloads Public Shared Sub PrintCountsAndBytes(s As String, 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(s)
      Console.Write(" {0,-3}", iBC)

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

      ' Encode the entire string.
      Dim bytes As Byte() = enc.GetBytes(s)

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   Overloads Public Shared Sub PrintCountsAndBytes(s As String, index As Integer, count As Integer, 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(s.ToCharArray(), index, count)
      Console.Write(" {0,-3}", iBC)

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

      ' Encode a range of characters in the string.
      ' NOTE: In VB.NET, arrays contain one extra element by default.
      '       The following line creates the array with the exact number of elements required.
      Dim bytes(iBC - 1) As Byte
      enc.GetBytes(s, index, count, bytes, bytes.GetLowerBound(0))

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   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

End Class


'This code produces the following output.
'
'Encoding the entire string:
'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
'
'Encoding the characters from index 4 through 6:
'System.Text.UTF7Encoding       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
'System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
'System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
'System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
'System.Text.UTF32Encoding      : 8   16  :B2 03 00 00 FF FC 04 00

Comentários

Para calcular o tamanho exato da matriz exigido pelo GetBytes para armazenar os bytes resultantes, chame o método GetByteCount.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Para calcular o tamanho máximo da matriz, chame o método GetMaxByteCount.To calculate the maximum array size, call the GetMaxByteCount method. O método GetByteCount geralmente permite a alocação de menos memória, enquanto o método GetMaxByteCount geralmente é executado mais rapidamente.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

O método GetByteCount determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode e o método GetBytes executa a codificação real.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. O método GetBytes espera conversões discretas, ao contrário do método Encoder.GetBytes, que lida com várias conversões em um único fluxo de entrada.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Há suporte para várias versões do GetByteCount e GetBytes.Several versions of GetByteCount and GetBytes are supported. A seguir estão algumas considerações de programação para o uso desses métodos:The following are some programming considerations for use of these methods:

  • Seu aplicativo pode precisar codificar muitos caracteres de entrada em uma página de código e processar os caracteres usando várias chamadas.Your app might need to encode many input characters to a code page and process the characters using multiple calls. Nesse caso, é provável que você precise manter o estado entre as chamadas, levando em conta o estado que é persistido pelo objeto de Encoder que está sendo usado.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Se o seu aplicativo lida com entradas de cadeia de caracteres, a versão de cadeia de caracteres do GetBytes é recomendada.If your app handles string inputs, the string version of GetBytes is recommended.

  • A versão de buffer de caracteres Unicode do GetBytes(Char*, Int32, Byte*, Int32) permite algumas técnicas rápidas, especialmente com várias chamadas usando o objeto Encoder ou inserindo em buffers existentes.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. No entanto, lembre-se de que essa versão do método às vezes não é segura, já que os ponteiros são necessários.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Se seu aplicativo precisar converter uma grande quantidade de dados, ele deverá reutilizar o buffer de saída.If your app must convert a large amount of data, it should reuse the output buffer. Nesse caso, a versão GetBytes que dá suporte a matrizes de bytes é a melhor opção.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Considere usar o método Encoder.Convert em vez de GetByteCount.Consider using the Encoder.Convert method instead of GetByteCount. O método de conversão converte o máximo de dados possível e gera uma exceção se o buffer de saída for muito pequeno.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Para a codificação contínua de um fluxo, esse método geralmente é a melhor opção.For continuous encoding of a stream, this method is often the best choice.

Veja também

GetByteCount(ReadOnlySpan<Char>)

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação dos caracteres no intervalo de caracteres especificado.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified character span.

public:
 virtual int GetByteCount(ReadOnlySpan<char> chars);
public virtual int GetByteCount (ReadOnlySpan<char> chars);
abstract member GetByteCount : ReadOnlySpan<char> -> int
override this.GetByteCount : ReadOnlySpan<char> -> int
Public Overridable Function GetByteCount (chars As ReadOnlySpan(Of Char)) As Integer

Parâmetros

chars
ReadOnlySpan<Char>

O intervalo de caracteres a ser codificado.The span of characters to encode.

Retornos

O número de bytes produzidos pela codificação do intervalo de caracteres especificado.The number of bytes produced by encoding the specified character span.

Comentários

Para calcular o tamanho exato de span exigido pelo GetBytes para armazenar os bytes resultantes, chame o método GetByteCount.To calculate the exact span size required by GetBytes to store the resulting bytes, call the GetByteCount method. Para calcular o tamanho máximo do intervalo, chame o método GetMaxByteCount.To calculate the maximum span size, call the GetMaxByteCount method. O método GetByteCount geralmente permite a alocação de menos memória, enquanto o método GetMaxByteCount geralmente é executado mais rapidamente.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

O método GetByteCount determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode e o método GetBytes executa a codificação real.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. O método GetBytes espera conversões discretas, ao contrário do método Encoder.GetBytes, que lida com várias conversões em um único fluxo de entrada.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Há suporte para várias versões do GetByteCount e GetBytes.Several versions of GetByteCount and GetBytes are supported. A seguir estão algumas considerações de programação para o uso desses métodos:The following are some programming considerations for use of these methods:

  • Seu aplicativo pode precisar codificar muitos caracteres de entrada em uma página de código e processar os caracteres usando várias chamadas.Your app might need to encode many input characters to a code page and process the characters using multiple calls. Nesse caso, é provável que você precise manter o estado entre as chamadas, levando em conta o estado que é persistido pelo objeto de Encoder que está sendo usado.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Se seu aplicativo lida com o alcance de entradas de caracteres, a versão de span do GetBytes é recomendada.If your app handles span of characters inputs, the span version of GetBytes is recommended.

  • Considere usar o método Encoder.Convert em vez de GetByteCount.Consider using the Encoder.Convert method instead of GetByteCount. O método de conversão converte o máximo de dados possível e lança uma exceção se o buffer de span de saída for muito pequeno.The conversion method converts as much data as possible, and does throw an exception if the output span buffer is too small. Para a codificação contínua de um fluxo, esse método geralmente é a melhor opção.For continuous encoding of a stream, this method is often the best choice.

GetByteCount(Char[])

Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de todos os caracteres na matriz de caracteres especificada.When overridden in a derived class, calculates the number of bytes produced by encoding all the characters in the specified character array.

public:
 virtual int GetByteCount(cli::array <char> ^ chars);
public virtual int GetByteCount (char[] chars);
abstract member GetByteCount : char[] -> int
override this.GetByteCount : char[] -> int
Public Overridable Function GetByteCount (chars As Char()) As Integer

Parâmetros

chars
Char[]

A matriz de caracteres que contém os caracteres a serem codificados.The character array containing the characters to encode.

Retornos

O número de bytes produzidos codificando todos os caracteres na matriz de caracteres especificada.The number of bytes produced by encoding all the characters in the specified character array.

Exceções

chars é null.chars is null.

Ocorreu um fallback (saiba mais em Codificação de caracteres no .NET)A fallback occurred (for more information, see Character Encoding in .NET)

-e--and-

EncoderFallback é definido como EncoderExceptionFallback.EncoderFallback is set to EncoderExceptionFallback.

Exemplos

O exemplo a seguir determina o número de bytes necessários para codificar uma matriz de caracteres, codifica os caracteres e exibe os 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.Text

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


   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


   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

End Class


'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

Comentários

Para calcular o tamanho exato da matriz exigido pelo GetBytes para armazenar os bytes resultantes, chame o método GetByteCount.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Para calcular o tamanho máximo da matriz, chame o método GetMaxByteCount.To calculate the maximum array size, call the GetMaxByteCount method. O método GetByteCount geralmente permite a alocação de menos memória, enquanto o método GetMaxByteCount geralmente é executado mais rapidamente.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

O método GetByteCount determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode e o método GetBytes executa a codificação real.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. O método GetBytes espera conversões discretas, ao contrário do método Encoder.GetBytes, que lida com várias conversões em um único fluxo de entrada.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Há suporte para várias versões do GetByteCount e GetBytes.Several versions of GetByteCount and GetBytes are supported. A seguir estão algumas considerações de programação para o uso desses métodos:The following are some programming considerations for use of these methods:

  • Seu aplicativo pode precisar codificar muitos caracteres de entrada em uma página de código e processar os caracteres usando várias chamadas.Your app might need to encode many input characters to a code page and process the characters using multiple calls. Nesse caso, é provável que você precise manter o estado entre as chamadas, levando em conta o estado que é persistido pelo objeto de Encoder que está sendo usado.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Se seu aplicativo lida com entradas de cadeia de caracteres, você deve usar as versões de cadeia de caracteres do método GetBytes.If your app handles string inputs, you should use the string versions of the GetBytes method.

  • A versão de buffer de caracteres Unicode do GetBytes(Char*, Int32, Byte*, Int32) permite algumas técnicas rápidas, especialmente com várias chamadas usando o objeto Encoder ou inserindo em buffers existentes.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. No entanto, lembre-se de que essa versão do método às vezes não é segura, já que os ponteiros são necessários.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Se seu aplicativo precisar converter uma grande quantidade de dados, você deverá reutilizar o buffer de saída.If your app must convert a large amount of data, you should reuse the output buffer. Nesse caso, a versão GetBytes que dá suporte a matrizes de bytes é a melhor opção.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Considere usar o método Encoder.Convert em vez de GetByteCount.Consider using the Encoder.Convert method instead of GetByteCount. O método de conversão converte o máximo de dados possível e gera uma exceção se o buffer de saída for muito pequeno.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Para a codificação contínua de um fluxo, esse método geralmente é a melhor opção.For continuous encoding of a stream, this method is often the best choice.

Veja também

Aplica-se a