Encoding.GetByteCount Método

Definição

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

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar um conjunto de caracteres.

Sobrecargas

Name Description
GetByteCount(String, Int32, Int32)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar um conjunto de caracteres a partir da cadeia especificada.
GetByteCount(Char[], Int32, Int32)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar um conjunto de caracteres a partir do array de caracteres especificado.
GetByteCount(Char*, Int32)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar um conjunto de caracteres a partir do ponteiro especificado.
GetByteCount(String)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos pela codificação dos caracteres na cadeia especificada.
GetByteCount(ReadOnlySpan<Char>)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos pela codificação dos caracteres no intervalo de caracteres especificado.
GetByteCount(Char[])

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar todos os caracteres do array de caracteres especificado.

GetByteCount(String, Int32, Int32)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar um conjunto de caracteres a partir da cadeia especificada.

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

Int32

O número de bytes produzidos pela codificação da cadeia.

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, chama 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.

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.

  • Se a tua aplicação gerir entradas de cadeias, recomenda-se a versão GetBytes de cadeia.

  • 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

GetByteCount(Char[], Int32, Int32)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar um conjunto de caracteres a partir do array de caracteres especificado.

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[]

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

Int32

O número de bytes produzidos pela codificação dos caracteres especificados.

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

Para calcular o tamanho exato do array necessário GetBytes para armazenar os bytes resultantes, chama 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.

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.

  • Se a tua aplicação gerir entradas de cadeias, recomenda-se a versão GetBytes de cadeia.

  • 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

GetByteCount(Char*, Int32)

Importante

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

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar um conjunto de caracteres a partir do ponteiro especificado.

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

Parâmetros

chars
Char*

Um apontador para o primeiro carácter a codificar.

count
Int32

O número de caracteres a codificar.

Devoluções

Int32

O número de bytes produzidos pela codificação dos caracteres especificados.

Atributos
CLSCompliantAttribute SecurityCriticalAttribute ComVisibleAttribute

Exceções

ArgumentNullException

chars é null.

ArgumentOutOfRangeException

count é inferior a zero.

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

O GetByteCount(Char*, Int32) método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode, e o GetBytes(Char*, Int32, Byte*, Int32) 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 para a utilização destes métodos:

  • A sua aplicação pode precisar de codificar muitos caracteres de entrada numa página de códigos 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.

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

  • A versão GetBytes 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

GetByteCount(String)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos pela codificação dos caracteres na cadeia especificada.

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 que contém o conjunto de caracteres a codificar.

Devoluções

Int32

O número de bytes produzidos pela codificação dos caracteres especificados.

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

Para calcular o tamanho exato do array necessário GetBytes para armazenar os bytes resultantes, chama 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.

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.

  • Se a tua aplicação gerir entradas de cadeias, recomenda-se a versão GetBytes de cadeia.

  • 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

GetByteCount(ReadOnlySpan<Char>)

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos pela codificação dos caracteres no intervalo de caracteres especificado.

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 número de caracteres a codificar.

Devoluções

Int32

O número de bytes produzidos ao codificar o intervalo de caracteres especificado.

Observações

Para calcular o tamanho exato do span necessário para GetBytes armazenar os bytes resultantes, chame-se o GetByteCount método. Para calcular o tamanho máximo do vão, chame 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.

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.

  • Se a tua aplicação gerir entradas de span de caracteres, recomenda-se a versão span.GetBytes

  • 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 expansão 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

GetByteCount(Char[])

Quando sobrescrito numa classe derivada, calcula o número de bytes produzidos ao codificar todos os caracteres do array de caracteres especificado.

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[]

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

Devoluções

Int32

O número de bytes produzidos ao codificar todos os caracteres do array de caracteres especificado.

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

Para calcular o tamanho exato do array necessário GetBytes para armazenar os bytes resultantes, chama 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.

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.

  • Se a tua aplicação gere entradas de strings, deves usar as versões 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