Encoding.GetBytes Método

Definição

Espaço de Nomes:
System.Text
Assemblagens:
mscorlib.dll, System.Text.Encoding.dll
Assemblagem:
mscorlib.dll
Assemblagem:
System.Text.Encoding.dll
Assemblagem:
netstandard.dll

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres numa sequência de bytes.

Sobrecargas

Name Description
GetBytes(Char[])

Quando sobrescrito numa classe derivada, codifica todos os caracteres do array de caracteres especificado numa sequência de bytes.
GetBytes(String)

Quando sobrescrito numa classe derivada, codifica todos os caracteres da cadeia especificada numa sequência de bytes.
GetBytes(ReadOnlySpan<Char>, Span<Byte>)

Quando sobrescrito numa classe derivada, codifica num espaço de bytes um conjunto de caracteres do intervalo de apenas leitura especificado.
GetBytes(Char[], Int32, Int32)

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres do array de caracteres especificado numa sequência de bytes.
GetBytes(String, Int32, Int32)

Quando sobrescrito numa classe derivada, codifica num array de bytes o número de caracteres especificados por count na cadeia especificada, começando a partir do especificado index.
GetBytes(Char*, Int32, Byte*, Int32)

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres a partir do ponteiro especificado numa sequência de bytes que são armazenados a partir do ponteiro de byte especificado.
GetBytes(Char[], Int32, Int32, Byte[], Int32)

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres do array de caracteres especificado para o array de bytes especificado.
GetBytes(String, Int32, Int32, Byte[], Int32)

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres da cadeia especificada para o array de bytes especificado.

GetBytes(Char[])

Quando sobrescrito numa classe derivada, codifica todos os caracteres do array de caracteres especificado numa sequência de bytes.

public:
 virtual cli::array <System::Byte> ^ GetBytes(cli::array <char> ^ chars);
public virtual byte[] GetBytes(char[] chars);
abstract member GetBytes : char[] -> byte[]
override this.GetBytes : char[] -> byte[]
Public Overridable Function GetBytes (chars As Char()) As Byte()

Parâmetros

chars
Char[]

O array de caracteres que contém os caracteres a codificar.

Devoluções

Byte[]

Um array de bytes contendo os resultados da codificação do conjunto especificado de caracteres.

Exceções

ArgumentNullException

chars é null.

EncoderFallbackException

Ocorreu um recurso de recurso (para mais informações, veja Codificação de Caracteres em .NET)

- e -

EncoderFallback está definido como EncoderExceptionFallback.

Exemplos

O exemplo seguinte determina o número de bytes necessários para codificar um array de caracteres, codifica os caracteres e apresenta os bytes resultantes.

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

Observações

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precise ser dividida em blocos menores, você deverá usar o Decoder ou o Encoder fornecidos pelo método GetDecoder ou pelo método GetEncoder, respectivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gerir entradas de strings, deves chamar a versão string do GetBytes método.

  • A versão GetBytes(Char*, Int32, Byte*, Int32) com buffer de caracteres Unicode permite algumas técnicas rápidas, particularmente com múltiplas chamadas usando o Encoder objeto ou inserindo em buffers existentes. Tenha em mente, no entanto, que esta versão do método por vezes não é segura, pois são necessários ponteiros.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Ver também

Aplica-se a

GetBytes(String)

Quando sobrescrito numa classe derivada, codifica todos os caracteres da cadeia especificada numa sequência de bytes.

public:
 virtual cli::array <System::Byte> ^ GetBytes(System::String ^ s);
public virtual byte[] GetBytes(string s);
abstract member GetBytes : string -> byte[]
override this.GetBytes : string -> byte[]
Public Overridable Function GetBytes (s As String) As Byte()

Parâmetros

s
String

A cadeia que contém os caracteres a codificar.

Devoluções

Byte[]

Um array de bytes contendo os resultados da codificação do conjunto especificado de caracteres.

Exceções

ArgumentNullException

s é null.

EncoderFallbackException

Ocorreu um recurso de recurso (para mais informações, veja Codificação de Caracteres em .NET)

- e -

EncoderFallback está definido como EncoderExceptionFallback.

Exemplos

O exemplo seguinte determina o número de bytes necessários para codificar uma cadeia ou um intervalo na cadeia, codifica os caracteres e apresenta os bytes resultantes.

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

Observações

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precise ser dividida em blocos menores, você deverá usar o Decoder ou o Encoder fornecidos pelo método GetDecoder ou pelo método GetEncoder, respectivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O Encoding.GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gere entradas de cadeias, deves usar a versão de strings de GetBytes.

  • A versão GetBytes(Char*, Int32, Byte*, Int32) com buffer de caracteres Unicode permite algumas técnicas rápidas, particularmente com múltiplas chamadas usando o Encoder objeto ou inserindo em buffers existentes. Tenha em mente, no entanto, que esta versão do método por vezes não é segura, pois são necessários ponteiros.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Ver também

Aplica-se a

GetBytes(ReadOnlySpan<Char>, Span<Byte>)

Quando sobrescrito numa classe derivada, codifica num espaço de bytes um conjunto de caracteres do intervalo de apenas leitura especificado.

public:
 virtual int GetBytes(ReadOnlySpan<char> chars, Span<System::Byte> bytes);
public virtual int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes);
abstract member GetBytes : ReadOnlySpan<char> * Span<byte> -> int
override this.GetBytes : ReadOnlySpan<char> * Span<byte> -> int
Public Overridable Function GetBytes (chars As ReadOnlySpan(Of Char), bytes As Span(Of Byte)) As Integer

Parâmetros

chars
ReadOnlySpan<Char>

O espaço que contém o conjunto de caracteres a codificar.

bytes
Span<Byte>

O intervalo de bytes para conter os bytes codificados.

Devoluções

Int32

O número de bytes codificados.

Observações

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precise ser dividida em blocos menores, você deverá usar o Decoder ou o Encoder fornecidos pelo método GetDecoder ou pelo método GetEncoder, respectivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O Encoding.GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gere entradas de cadeias, deves usar a versão de strings de GetBytes.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Aplica-se a

GetBytes(Char[], Int32, Int32)

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres do array de caracteres especificado numa sequência de bytes.

public:
 virtual cli::array <System::Byte> ^ GetBytes(cli::array <char> ^ chars, int index, int count);
public virtual byte[] GetBytes(char[] chars, int index, int count);
abstract member GetBytes : char[] * int * int -> byte[]
override this.GetBytes : char[] * int * int -> byte[]
Public Overridable Function GetBytes (chars As Char(), index As Integer, count As Integer) As Byte()

Parâmetros

chars
Char[]

O array de caracteres que contém o conjunto de caracteres a codificar.

index
Int32

O índice do primeiro carácter a codificar.

count
Int32

O número de caracteres a codificar.

Devoluções

Byte[]

Um array de bytes contendo os resultados da codificação do conjunto especificado de caracteres.

Exceções

ArgumentNullException

chars é null.

ArgumentOutOfRangeException

index ou count é inferior a zero.

-ou-

index e count não denotam um intervalo válido em chars.

EncoderFallbackException

Ocorreu um recurso de recurso (para mais informações, veja Codificação de Caracteres em .NET)

- e -

EncoderFallback está definido como EncoderExceptionFallback.

Exemplos

O exemplo seguinte determina o número de bytes necessários para codificar três caracteres de um array de caracteres, codifica os caracteres e apresenta os bytes resultantes.

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

Observações

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precise ser dividida em blocos menores, você deverá usar o Decoder ou o Encoder fornecidos pelo método GetDecoder ou pelo método GetEncoder, respectivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O Encoding.GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gere entradas de cadeias, deves usar a versão de strings de GetBytes.

  • A versão GetBytes(Char*, Int32, Byte*, Int32) com buffer de caracteres Unicode permite algumas técnicas rápidas, particularmente com múltiplas chamadas usando o Encoder objeto ou inserindo em buffers existentes. Tenha em mente, no entanto, que esta versão do método por vezes não é segura, pois são necessários ponteiros.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Ver também

Aplica-se a

GetBytes(String, Int32, Int32)

Quando sobrescrito numa classe derivada, codifica num array de bytes o número de caracteres especificados por count na cadeia especificada, começando a partir do especificado index.

public:
 cli::array <System::Byte> ^ GetBytes(System::String ^ s, int index, int count);
public byte[] GetBytes(string s, int index, int count);
member this.GetBytes : string * int * int -> byte[]
Public Function GetBytes (s As String, index As Integer, count As Integer) As Byte()

Parâmetros

s
String

A cadeia que contém os caracteres a codificar.

index
Int32

O índice dentro da cadeia para iniciar a codificação.

count
Int32

O número de caracteres a codificar.

Devoluções

Byte[]

Um array de bytes contendo os resultados da codificação do conjunto especificado de caracteres.

Exemplos

O exemplo seguinte determina o número de bytes necessários para codificar uma cadeia ou um intervalo na cadeia, codifica os caracteres e apresenta os bytes resultantes.

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

Observações

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precise ser dividida em blocos menores, você deverá usar o Decoder ou o Encoder fornecidos pelo método GetDecoder ou pelo método GetEncoder, respectivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O Encoding.GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gere entradas de cadeias, deves usar a versão de strings de GetBytes.

  • A versão GetBytes(Char*, Int32, Byte*, Int32) com buffer de caracteres Unicode permite algumas técnicas rápidas, particularmente com múltiplas chamadas usando o Encoder objeto ou inserindo em buffers existentes. Tenha em mente, no entanto, que esta versão do método por vezes não é segura, pois são necessários ponteiros.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Aplica-se a

GetBytes(Char*, Int32, Byte*, Int32)

Importante

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

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres a partir do ponteiro especificado numa sequência de bytes que são armazenados a partir do ponteiro de byte especificado.

public:
 virtual int GetBytes(char* chars, int charCount, System::Byte* bytes, int byteCount);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount);
[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
[System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount);
[System.CLSCompliant(false)]
public virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount);
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
abstract member GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int
override this.GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int
[<System.CLSCompliant(false)>]
[<System.Runtime.InteropServices.ComVisible(false)>]
abstract member GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int
override this.GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
[<System.Runtime.InteropServices.ComVisible(false)>]
abstract member GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int
override this.GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int
[<System.CLSCompliant(false)>]
abstract member GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int
override this.GetBytes : nativeptr<char> * int * nativeptr<byte> * int -> int

Parâmetros

chars
Char*

Um apontador para o primeiro carácter a codificar.

charCount
Int32

O número de caracteres a codificar.

bytes
Byte*

Um apontador para o local onde começar a escrever a sequência resultante de bytes.

byteCount
Int32

O número máximo de bytes a escrever.

Devoluções

Int32

O número real de bytes escritos na localização indicada pelo bytes parâmetro.

Atributos
CLSCompliantAttribute SecurityCriticalAttribute ComVisibleAttribute

Exceções

ArgumentNullException

chars é null.

-ou-

bytes é null.

ArgumentOutOfRangeException

charCount ou byteCount é inferior a zero.

ArgumentException

byteCount é menor do que o número resultante de bytes.

EncoderFallbackException

Ocorreu um recurso de recurso (para mais informações, veja Codificação de Caracteres em .NET)

- e -

EncoderFallback está definido como EncoderExceptionFallback.

Observações

Para calcular o tamanho exato do array que GetBytes requer armazenar os bytes resultantes, chame o GetByteCount método. Para calcular o tamanho máximo do array, chama o GetMaxByteCount método. O GetByteCount método geralmente permite a alocação de menos memória, enquanto o GetMaxByteCount método geralmente é executado mais rapidamente.

Se os dados a converter estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precisa de ser dividida em blocos mais pequenos, deve usar o Decoder ou o Encoder objeto fornecido pelo GetDecoder ou o GetEncoder método, respetivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gere entradas de cadeias, deves usar a versão de strings de GetBytes.

  • A versão GetBytes(Char*, Int32, Byte*, Int32) com buffer de caracteres Unicode permite algumas técnicas rápidas, particularmente com múltiplas chamadas usando o Encoder objeto ou inserindo em buffers existentes. Tenha em mente, no entanto, que esta versão do método por vezes não é segura, pois são necessários ponteiros.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Ver também

Aplica-se a

GetBytes(Char[], Int32, Int32, Byte[], Int32)

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres do array de caracteres especificado para o array de bytes especificado.

public:
 abstract int GetBytes(cli::array <char> ^ chars, int charIndex, int charCount, cli::array <System::Byte> ^ bytes, int byteIndex);
public abstract int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex);
abstract member GetBytes : char[] * int * int * byte[] * int -> int
Public MustOverride Function GetBytes (chars As Char(), charIndex As Integer, charCount As Integer, bytes As Byte(), byteIndex As Integer) As Integer

Parâmetros

chars
Char[]

O array de caracteres que contém o conjunto de caracteres a codificar.

charIndex
Int32

O índice do primeiro carácter a codificar.

charCount
Int32

O número de caracteres a codificar.

bytes
Byte[]

O array de bytes para conter a sequência resultante de bytes.

byteIndex
Int32

O índice onde começar a escrever a sequência resultante de bytes.

Devoluções

Int32

O número real de bytes escritos em bytes.

Exceções

ArgumentNullException

chars é null.

-ou-

bytes é null.

ArgumentOutOfRangeException

charIndex ou charCount ou byteIndex é menor que zero.

-ou-

charIndex e charCount não denotam um intervalo válido em chars.

-ou-

byteIndex não é um índice válido em bytes.

ArgumentException

bytes não tem capacidade suficiente de byteIndex até ao fim do array para acomodar os bytes resultantes.

EncoderFallbackException

Ocorreu um recurso de recurso (para mais informações, veja Codificação de Caracteres em .NET)

- e -

EncoderFallback está definido como EncoderExceptionFallback.

Exemplos

O exemplo seguinte determina o número de bytes necessários para codificar três caracteres de um array de caracteres, codifica os caracteres e apresenta os bytes resultantes.

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

Observações

Para calcular o tamanho exato do array necessário GetBytes para armazenar os bytes resultantes, deve chamar o GetByteCount método. Para calcular o tamanho máximo do array, chama o GetMaxByteCount método. O GetByteCount método geralmente permite a alocação de menos memória, enquanto o GetMaxByteCount método geralmente é executado mais rapidamente.

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precise ser dividida em blocos menores, você deverá usar o Decoder ou o Encoder fornecidos pelo método GetDecoder ou pelo método GetEncoder, respectivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O Encoding.GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gere entradas de cadeias, deves usar a versão de strings de GetBytes.

  • A versão GetBytes(Char*, Int32, Byte*, Int32) com buffer de caracteres Unicode permite algumas técnicas rápidas, particularmente com múltiplas chamadas usando o Encoder objeto ou inserindo em buffers existentes. Tenha em mente, no entanto, que esta versão do método por vezes não é segura, pois são necessários ponteiros.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Ver também

Aplica-se a

GetBytes(String, Int32, Int32, Byte[], Int32)

Quando sobrescrito numa classe derivada, codifica um conjunto de caracteres da cadeia especificada para o array de bytes especificado.

public:
 virtual int GetBytes(System::String ^ s, int charIndex, int charCount, cli::array <System::Byte> ^ bytes, int byteIndex);
public virtual int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex);
abstract member GetBytes : string * int * int * byte[] * int -> int
override this.GetBytes : string * int * int * byte[] * int -> int
Public Overridable Function GetBytes (s As String, charIndex As Integer, charCount As Integer, bytes As Byte(), byteIndex As Integer) As Integer

Parâmetros

s
String

A cadeia que contém o conjunto de caracteres a codificar.

charIndex
Int32

O índice do primeiro carácter a codificar.

charCount
Int32

O número de caracteres a codificar.

bytes
Byte[]

O array de bytes para conter a sequência resultante de bytes.

byteIndex
Int32

O índice onde começar a escrever a sequência resultante de bytes.

Devoluções

Int32

O número real de bytes escritos em bytes.

Exceções

ArgumentNullException

s é null.

-ou-

bytes é null.

ArgumentOutOfRangeException

charIndex ou charCount ou byteIndex é menor que zero.

-ou-

charIndex e charCount não denotam um intervalo válido em s.

-ou-

byteIndex não é um índice válido em bytes.

ArgumentException

bytes não tem capacidade suficiente de byteIndex até ao fim do array para acomodar os bytes resultantes.

EncoderFallbackException

Ocorreu um recurso de recurso (para mais informações, veja Codificação de Caracteres em .NET)

- e -

EncoderFallback está definido como EncoderExceptionFallback.

Exemplos

O exemplo seguinte determina o número de bytes necessários para codificar uma cadeia ou um intervalo na cadeia, codifica os caracteres e apresenta os bytes resultantes.

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

Observações

Para calcular o tamanho exato do array necessário GetBytes para armazenar os bytes resultantes, deve chamar o GetByteCount método. Para calcular o tamanho máximo do array, chama o GetMaxByteCount método. O GetByteCount método geralmente permite a alocação de menos memória, enquanto o GetMaxByteCount método geralmente é executado mais rapidamente.

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precise ser dividida em blocos menores, você deverá usar o Decoder ou o Encoder fornecidos pelo método GetDecoder ou pelo método GetEncoder, respectivamente, de uma classe derivada.

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes método executa a codificação propriamente dita. O Encoding.GetBytes método espera conversões discretas, ao contrário do Encoder.GetBytes método, que gere múltiplas conversões num único fluxo de entrada.

Várias versões de GetByteCount e GetBytes são suportadas. Seguem-se algumas considerações de programação para a utilização destes métodos:

  • A tua aplicação pode precisar de codificar muitos caracteres de entrada numa página de código e processar os caracteres usando múltiplas chamadas. Neste caso, provavelmente precisa de manter o estado entre chamadas, tendo em conta o estado que é mantido pelo Encoder objeto utilizado. (Por exemplo, uma sequência de caracteres que inclui pares de substitutos pode terminar com um substituto elevado. O Encoder vai lembrar-se que o substituto alto pode ser combinado com um substituto baixo no início de uma chamada seguinte. Encoding não conseguirá manter o estado, pelo que o carácter será enviado para o EncoderFallback.)

  • Se a tua aplicação gere entradas de cadeias, deves usar a versão de strings de GetBytes.

  • A versão GetBytes(Char*, Int32, Byte*, Int32) com buffer de caracteres Unicode permite algumas técnicas rápidas, particularmente com múltiplas chamadas usando o Encoder objeto ou inserindo em buffers existentes. Tenha em mente, no entanto, que esta versão do método por vezes não é segura, pois são necessários ponteiros.

  • Se a sua aplicação tiver de converter uma grande quantidade de dados, deve reutilizar o buffer de saída. Neste caso, a GetBytes versão que suporta arrays de bytes é a melhor escolha.

  • Considere usar o Encoder.Convert método em vez de 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 saída for demasiado pequeno. Para a codificação contínua de um fluxo, este método é frequentemente a melhor escolha.

Ver também

Aplica-se a