Encoding.GetByteCount Metoda

Definice

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování sady znaků.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters.

Přetížení

GetByteCount(Char[], Int32, Int32)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování sady znaků ze zadaného pole znaků.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified character array.

GetByteCount(String, Int32, Int32)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování sady znaků ze zadaného řetězce.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified string.

GetByteCount(Char*, Int32)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování sady znaků počínaje zadaným ukazatelem znaku.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.

GetByteCount(ReadOnlySpan<Char>)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných kódováním znaků v zadaném znakovém rozsahu.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified character span.

GetByteCount(Char[])

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování všech znaků v zadaném poli znaků.When overridden in a derived class, calculates the number of bytes produced by encoding all the characters in the specified character array.

GetByteCount(String)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných kódováním znaků v zadaném řetězci.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified string.

GetByteCount(Char[], Int32, Int32)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování sady znaků ze zadaného pole znaků.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified character array.

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

Parametry

chars
Char[]

Pole znaků obsahující sadu znaků, které mají být zakódovány.The character array containing the set of characters to encode.

index
Int32

Index prvního znaku, který má být zakódován.The index of the first character to encode.

count
Int32

Počet znaků, které mají být zakódovány.The number of characters to encode.

Návraty

Int32

Počet bajtů vyprodukovaných kódováním zadaných znaků.The number of bytes produced by encoding the specified characters.

Výjimky

chars je null.chars is null.

index nebo count je menší než nula.index or count is less than zero.

-nebo--or-

index a count neměňte si platný rozsah v chars .index and count do not denote a valid range in chars.

Došlo k chybě Fallback (Další informace najdete v tématu kódování znaků v rozhraní .NET).A fallback occurred (for more information, see Character Encoding in .NET)

ani-and-

EncoderFallback je nastaven na EncoderExceptionFallback .EncoderFallback is set to EncoderExceptionFallback.

Příklady

Následující příklad určuje počet bajtů potřebných ke kódování tří znaků z pole znaků, kódování znaků a zobrazení výsledných bajtů.The following example determines the number of bytes required to encode three characters from a character array, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( array<Char>^chars, int index, int count, Encoding^ enc );
void PrintHexBytes( array<Byte>^bytes );
int main()
{
   
   // The characters to encode:
   //    Latin Small Letter Z (U+007A)
   //    Latin Small Letter A (U+0061)
   //    Combining Breve (U+0306)
   //    Latin Small Letter AE With Acute (U+01FD)
   //    Greek Small Letter Beta (U+03B2)
   //    a high-surrogate value (U+D8FF)
   //    a low-surrogate value (U+DCFF)
   array<Char>^myChars = gcnew array<Char>{
      L'z',L'a',L'\u0306',L'\u01FD',L'\u03B2',L'\xD8FF',L'\xDCFF'
   };
   
   // Get different encodings.
   Encoding^ u7 = Encoding::UTF7;
   Encoding^ u8 = Encoding::UTF8;
   Encoding^ u16LE = Encoding::Unicode;
   Encoding^ u16BE = Encoding::BigEndianUnicode;
   Encoding^ u32 = Encoding::UTF32;
   
   // Encode three characters starting at index 4, and print out the counts and the resulting bytes.
   PrintCountsAndBytes( myChars, 4, 3, u7 );
   PrintCountsAndBytes( myChars, 4, 3, u8 );
   PrintCountsAndBytes( myChars, 4, 3, u16LE );
   PrintCountsAndBytes( myChars, 4, 3, u16BE );
   PrintCountsAndBytes( myChars, 4, 3, u32 );
}

void PrintCountsAndBytes( array<Char>^chars, int index, int count, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-30} :", enc );
   
   // Display the exact byte count.
   int iBC = enc->GetByteCount( chars, index, count );
   Console::Write( " {0,-3}", iBC );
   
   // Display the maximum byte count.
   int iMBC = enc->GetMaxByteCount( count );
   Console::Write( " {0,-3} :", iMBC );
   
   // Encode the array of chars.
   array<Byte>^bytes = enc->GetBytes( chars, index, count );
   
   // The following is an alternative way to encode the array of chars:
   // byte[] bytes = new byte[iBC];
   // enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) );
   // Display all the encoded bytes.
   PrintHexBytes( bytes );
}

void PrintHexBytes( array<Byte>^bytes )
{
   if ( (bytes == nullptr) || (bytes->Length == 0) )
      Console::WriteLine( "<none>" );
   else
   {
      for ( int i = 0; i < bytes->Length; i++ )
         Console::Write( "{0:X2} ", bytes[ i ] );
      Console::WriteLine();
   }
}

/* 
This code produces the following output.

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

*/
using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

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

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

      // Encode three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes( myChars, 4, 3, u7 );
      PrintCountsAndBytes( myChars, 4, 3, u8 );
      PrintCountsAndBytes( myChars, 4, 3, u16LE );
      PrintCountsAndBytes( myChars, 4, 3, u16BE );
      PrintCountsAndBytes( myChars, 4, 3, u32 );
   }

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

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

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

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

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

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

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

   public static void PrintHexBytes( byte[] bytes )  {

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


/* 
This code produces the following output.

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

*/
Imports System.Text

Public Class SamplesEncoding   

   Public Shared Sub Main()

      ' The characters to encode:
      '    Latin Small Letter Z (U+007A)
      '    Latin Small Letter A (U+0061)
      '    Combining Breve (U+0306)
      '    Latin Small Letter AE With Acute (U+01FD)
      '    Greek Small Letter Beta (U+03B2)
      '    a high-surrogate value (U+D8FF)
      '    a low-surrogate value (U+DCFF)
      Dim myChars() As Char = {"z"c, "a"c, ChrW(&H0306), ChrW(&H01FD), ChrW(&H03B2), ChrW(&HD8FF), ChrW(&HDCFF) }

      ' Get different encodings.
      Dim u7 As Encoding = Encoding.UTF7
      Dim u8 As Encoding = Encoding.UTF8
      Dim u16LE As Encoding = Encoding.Unicode
      Dim u16BE As Encoding = Encoding.BigEndianUnicode
      Dim u32 As Encoding = Encoding.UTF32

      ' Encode three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes(myChars, 4, 3, u7)
      PrintCountsAndBytes(myChars, 4, 3, u8)
      PrintCountsAndBytes(myChars, 4, 3, u16LE)
      PrintCountsAndBytes(myChars, 4, 3, u16BE)
      PrintCountsAndBytes(myChars, 4, 3, u32)

   End Sub


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

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

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

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

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

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

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   Public Shared Sub PrintHexBytes(bytes() As Byte)

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

   End Sub

End Class


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

Poznámky

Chcete-li vypočítat přesnou velikost pole požadovanou GetBytes pro uložení výsledných bajtů, zavolejte GetByteCount metodu.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Chcete-li vypočítat maximální velikost pole, zavolejte GetMaxByteCount metodu.To calculate the maximum array size, call the GetMaxByteCount method. GetByteCountMetoda obecně umožňuje přidělení méně paměti, zatímco GetMaxByteCount metoda se obvykle provádí rychleji.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

GetByteCountMetoda určuje, kolik bajtů má za následek kódování sady znaků Unicode a GetBytes Metoda provede skutečné kódování.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. GetBytesMetoda očekává diskrétní převody na rozdíl od Encoder.GetBytes metody, která zpracovává více převodů v jednom vstupním datovém proudu.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

GetByteCountPodporuje se několik verzí a GetBytes .Several versions of GetByteCount and GetBytes are supported. Níže jsou uvedeny některé pokyny k programování pro použití těchto metod:The following are some programming considerations for use of these methods:

  • Vaše aplikace může potřebovat kódovat mnoho vstupních znaků na znakovou stránku a zpracovat tyto znaky pomocí více volání.Your app might need to encode many input characters to a code page and process the characters using multiple calls. V takovém případě pravděpodobně budete muset zachovat stav mezi voláními, přičemž Vezměte v úvahu stav, který je trvale Encoder použitým objektem.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Pokud vaše aplikace zpracovává vstupy řetězců, GetBytes je doporučena verze řetězce.If your app handles string inputs, the string version of GetBytes is recommended.

  • Verze vyrovnávací paměti znaků Unicode GetBytes(Char*, Int32, Byte*, Int32) umožňuje některé rychlé techniky, zejména s více voláními pomocí Encoder objektu nebo vložení do existujících vyrovnávacích pamětí.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. Pamatujte však, že tato verze metody je někdy nebezpečná, protože jsou vyžadovány ukazatele.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Pokud vaše aplikace musí převést velké množství dat, měla by znovu použít výstupní vyrovnávací paměť.If your app must convert a large amount of data, it should reuse the output buffer. V takovém případě GetBytes je nejlepší volbou verze, která podporuje pole bajtů.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Zvažte použití Encoder.Convert metody místo GetByteCount .Consider using the Encoder.Convert method instead of GetByteCount. Metoda převodu převede co nejvíce dat a vyvolá výjimku, pokud výstupní vyrovnávací paměť je příliš malá.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Pro průběžné kódování datového proudu je tato metoda často nejlepší volbou.For continuous encoding of a stream, this method is often the best choice.

Viz také

Platí pro

Produkt Introduced

GetByteCount(String, Int32, Int32)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování sady znaků ze zadaného řetězce.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified string.

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

Parametry

s
String

Řetězec obsahující sadu znaků, které mají být zakódovány.The string containing the set of characters to encode.

index
Int32

Index prvního znaku, který má být zakódován.The index of the first character to encode.

count
Int32

Počet znaků, které mají být zakódovány.The number of characters to encode.

Návraty

Int32

Počet bajtů vyprodukovaných kódováním řetězce.The number of bytes produced by encoding the string.

Příklady

Následující příklad určuje počet bajtů potřebných ke kódování tří znaků z pole znaků, kódování znaků a zobrazení výsledných bajtů.The following example determines the number of bytes required to encode three characters from a character array, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( array<Char>^chars, int index, int count, Encoding^ enc );
void PrintHexBytes( array<Byte>^bytes );
int main()
{
   
   // The characters to encode:
   //    Latin Small Letter Z (U+007A)
   //    Latin Small Letter A (U+0061)
   //    Combining Breve (U+0306)
   //    Latin Small Letter AE With Acute (U+01FD)
   //    Greek Small Letter Beta (U+03B2)
   //    a high-surrogate value (U+D8FF)
   //    a low-surrogate value (U+DCFF)
   array<Char>^myChars = gcnew array<Char>{
      L'z',L'a',L'\u0306',L'\u01FD',L'\u03B2',L'\xD8FF',L'\xDCFF'
   };
   
   // Get different encodings.
   Encoding^ u7 = Encoding::UTF7;
   Encoding^ u8 = Encoding::UTF8;
   Encoding^ u16LE = Encoding::Unicode;
   Encoding^ u16BE = Encoding::BigEndianUnicode;
   Encoding^ u32 = Encoding::UTF32;
   
   // Encode three characters starting at index 4, and print out the counts and the resulting bytes.
   PrintCountsAndBytes( myChars, 4, 3, u7 );
   PrintCountsAndBytes( myChars, 4, 3, u8 );
   PrintCountsAndBytes( myChars, 4, 3, u16LE );
   PrintCountsAndBytes( myChars, 4, 3, u16BE );
   PrintCountsAndBytes( myChars, 4, 3, u32 );
}

void PrintCountsAndBytes( array<Char>^chars, int index, int count, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-30} :", enc );
   
   // Display the exact byte count.
   int iBC = enc->GetByteCount( chars, index, count );
   Console::Write( " {0,-3}", iBC );
   
   // Display the maximum byte count.
   int iMBC = enc->GetMaxByteCount( count );
   Console::Write( " {0,-3} :", iMBC );
   
   // Encode the array of chars.
   array<Byte>^bytes = enc->GetBytes( chars, index, count );
   
   // The following is an alternative way to encode the array of chars:
   // byte[] bytes = new byte[iBC];
   // enc.GetBytes( chars, index, count, bytes, bytes.GetLowerBound(0) );
   // Display all the encoded bytes.
   PrintHexBytes( bytes );
}

void PrintHexBytes( array<Byte>^bytes )
{
   if ( (bytes == nullptr) || (bytes->Length == 0) )
      Console::WriteLine( "<none>" );
   else
   {
      for ( int i = 0; i < bytes->Length; i++ )
         Console::Write( "{0:X2} ", bytes[ i ] );
      Console::WriteLine();
   }
}

/* 
This code produces the following output.

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

*/
using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

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

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

      // Encode three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes( myChars, 4, 3, u7 );
      PrintCountsAndBytes( myChars, 4, 3, u8 );
      PrintCountsAndBytes( myChars, 4, 3, u16LE );
      PrintCountsAndBytes( myChars, 4, 3, u16BE );
      PrintCountsAndBytes( myChars, 4, 3, u32 );
   }

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

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

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

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

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

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

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

   public static void PrintHexBytes( byte[] bytes )  {

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


/* 
This code produces the following output.

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

*/
Imports System.Text

Public Class SamplesEncoding   

   Public Shared Sub Main()

      ' The characters to encode:
      '    Latin Small Letter Z (U+007A)
      '    Latin Small Letter A (U+0061)
      '    Combining Breve (U+0306)
      '    Latin Small Letter AE With Acute (U+01FD)
      '    Greek Small Letter Beta (U+03B2)
      '    a high-surrogate value (U+D8FF)
      '    a low-surrogate value (U+DCFF)
      Dim myChars() As Char = {"z"c, "a"c, ChrW(&H0306), ChrW(&H01FD), ChrW(&H03B2), ChrW(&HD8FF), ChrW(&HDCFF) }

      ' Get different encodings.
      Dim u7 As Encoding = Encoding.UTF7
      Dim u8 As Encoding = Encoding.UTF8
      Dim u16LE As Encoding = Encoding.Unicode
      Dim u16BE As Encoding = Encoding.BigEndianUnicode
      Dim u32 As Encoding = Encoding.UTF32

      ' Encode three characters starting at index 4, and print out the counts and the resulting bytes.
      PrintCountsAndBytes(myChars, 4, 3, u7)
      PrintCountsAndBytes(myChars, 4, 3, u8)
      PrintCountsAndBytes(myChars, 4, 3, u16LE)
      PrintCountsAndBytes(myChars, 4, 3, u16BE)
      PrintCountsAndBytes(myChars, 4, 3, u32)

   End Sub


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

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

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

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

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

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

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   Public Shared Sub PrintHexBytes(bytes() As Byte)

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

   End Sub

End Class


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

Poznámky

Chcete-li vypočítat přesnou velikost pole požadovanou GetBytes pro uložení výsledných bajtů, zavolejte GetByteCount metodu.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Chcete-li vypočítat maximální velikost pole, zavolejte GetMaxByteCount metodu.To calculate the maximum array size, call the GetMaxByteCount method. GetByteCountMetoda obecně umožňuje přidělení méně paměti, zatímco GetMaxByteCount metoda se obvykle provádí rychleji.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

GetByteCountMetoda určuje, kolik bajtů má za následek kódování sady znaků Unicode a GetBytes Metoda provede skutečné kódování.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. GetBytesMetoda očekává diskrétní převody na rozdíl od Encoder.GetBytes metody, která zpracovává více převodů v jednom vstupním datovém proudu.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

GetByteCountPodporuje se několik verzí a GetBytes .Several versions of GetByteCount and GetBytes are supported. Níže jsou uvedeny některé pokyny k programování pro použití těchto metod:The following are some programming considerations for use of these methods:

  • Vaše aplikace může potřebovat kódovat mnoho vstupních znaků na znakovou stránku a zpracovat tyto znaky pomocí více volání.Your app might need to encode many input characters to a code page and process the characters using multiple calls. V takovém případě pravděpodobně budete muset zachovat stav mezi voláními, přičemž Vezměte v úvahu stav, který je trvale Encoder použitým objektem.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Pokud vaše aplikace zpracovává vstupy řetězců, GetBytes je doporučena verze řetězce.If your app handles string inputs, the string version of GetBytes is recommended.

  • Verze vyrovnávací paměti znaků Unicode GetBytes(Char*, Int32, Byte*, Int32) umožňuje některé rychlé techniky, zejména s více voláními pomocí Encoder objektu nebo vložení do existujících vyrovnávacích pamětí.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. Pamatujte však, že tato verze metody je někdy nebezpečná, protože jsou vyžadovány ukazatele.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Pokud vaše aplikace musí převést velké množství dat, měla by znovu použít výstupní vyrovnávací paměť.If your app must convert a large amount of data, it should reuse the output buffer. V takovém případě GetBytes je nejlepší volbou verze, která podporuje pole bajtů.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Zvažte použití Encoder.Convert metody místo GetByteCount .Consider using the Encoder.Convert method instead of GetByteCount. Metoda převodu převede co nejvíce dat a vyvolá výjimku, pokud výstupní vyrovnávací paměť je příliš malá.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Pro průběžné kódování datového proudu je tato metoda často nejlepší volbou.For continuous encoding of a stream, this method is often the best choice.

Platí pro

Produkt Introduced

GetByteCount(Char*, Int32)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování sady znaků počínaje zadaným ukazatelem znaku.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.

public:
 virtual int GetByteCount(char* chars, int count);
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]
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);
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
[<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

Parametry

chars
Char*

Ukazatel na první znak ke kódování.A pointer to the first character to encode.

count
Int32

Počet znaků, které mají být zakódovány.The number of characters to encode.

Návraty

Int32

Počet bajtů vyprodukovaných kódováním zadaných znaků.The number of bytes produced by encoding the specified characters.

Atributy

Výjimky

chars je null.chars is null.

Hodnota count je menší než nula.count is less than zero.

Došlo k chybě Fallback (Další informace najdete v tématu kódování znaků v rozhraní .NET).A fallback occurred (for more information, see Character Encoding in .NET)

ani-and-

EncoderFallback je nastaven na EncoderExceptionFallback .EncoderFallback is set to EncoderExceptionFallback.

Poznámky

Chcete-li vypočítat přesnou velikost pole, která GetBytes vyžaduje uložení výsledných bajtů, měli byste zavolat GetByteCount metodu.To calculate the exact array size that GetBytes requires to store the resulting bytes, you should call the GetByteCount method. Chcete-li vypočítat maximální velikost pole, zavolejte GetMaxByteCount metodu.To calculate the maximum array size, call the GetMaxByteCount method. GetByteCountMetoda obecně umožňuje přidělení méně paměti, zatímco GetMaxByteCount metoda se obvykle provádí rychleji.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

GetByteCount(Char*, Int32)Metoda určuje, kolik bajtů má za následek kódování sady znaků Unicode a GetBytes(Char*, Int32, Byte*, Int32) Metoda provede skutečné kódování.The GetByteCount(Char*, Int32) method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes(Char*, Int32, Byte*, Int32) method performs the actual encoding. GetBytesMetoda očekává diskrétní převody na rozdíl od Encoder.GetBytes metody, která zpracovává více převodů v jednom vstupním datovém proudu.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

GetByteCountPodporuje se několik verzí a GetBytes .Several versions of GetByteCount and GetBytes are supported. Níže jsou uvedeny některé předpoklady pro použití těchto metod:The following are some considerations for using these methods:

  • Vaše aplikace může potřebovat kódovat mnoho vstupních znaků na znakovou stránku a zpracovat tyto znaky pomocí více volání.Your app may need to encode many input characters to a code page and process the characters using multiple calls. V takovém případě pravděpodobně budete muset zachovat stav mezi voláními, přičemž Vezměte v úvahu stav, který je trvale Encoder použitým objektem.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Pokud vaše aplikace zpracovává vstupy řetězců, měli byste použít řetězcovou verzi GetBytes metody.If your app handles string inputs, you should use the string version of the GetBytes method.

  • Verze vyrovnávací paměti znaků Unicode GetBytes umožňuje některé rychlé techniky, zejména s více voláními pomocí Encoder objektu nebo vložení do existujících vyrovnávacích pamětí.The Unicode character buffer version of GetBytes allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. Pamatujte však, že tato verze metody je někdy nebezpečná, protože jsou vyžadovány ukazatele.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Pokud vaše aplikace musí převést velké množství dat, měla by znovu použít výstupní vyrovnávací paměť.If your app must convert a large amount of data, it should reuse the output buffer. V takovém případě GetBytes je nejlepší volbou verze, která podporuje pole bajtů.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Zvažte použití Encoder.Convert metody místo GetByteCount .Consider using the Encoder.Convert method instead of GetByteCount. Metoda převodu převede co nejvíce dat a vyvolá výjimku, pokud výstupní vyrovnávací paměť je příliš malá.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Pro průběžné kódování datového proudu je tato metoda často nejlepší volbou.For continuous encoding of a stream, this method is often the best choice.

Viz také

Platí pro

Produkt Introduced

GetByteCount(ReadOnlySpan<Char>)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných kódováním znaků v zadaném znakovém rozsahu.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified character span.

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

Parametry

chars
ReadOnlySpan<Char>

Rozsah znaků, které mají být zakódovány.The span of characters to encode.

Návraty

Int32

Počet bajtů vyprodukovaných pomocí kódování zadaného rozsahu znaků.The number of bytes produced by encoding the specified character span.

Poznámky

Chcete-li vypočítat přesnou velikost rozsahu požadovanou GetBytes pro uložení výsledných bajtů, zavolejte GetByteCount metodu.To calculate the exact span size required by GetBytes to store the resulting bytes, call the GetByteCount method. Chcete-li vypočítat maximální velikost rozsahu, zavolejte GetMaxByteCount metodu.To calculate the maximum span size, call the GetMaxByteCount method. GetByteCountMetoda obecně umožňuje přidělení méně paměti, zatímco GetMaxByteCount metoda se obvykle provádí rychleji.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

GetByteCountMetoda určuje, kolik bajtů má za následek kódování sady znaků Unicode a GetBytes Metoda provede skutečné kódování.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. GetBytesMetoda očekává diskrétní převody na rozdíl od Encoder.GetBytes metody, která zpracovává více převodů v jednom vstupním datovém proudu.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

GetByteCountPodporuje se několik verzí a GetBytes .Several versions of GetByteCount and GetBytes are supported. Níže jsou uvedeny některé pokyny k programování pro použití těchto metod:The following are some programming considerations for use of these methods:

  • Vaše aplikace může potřebovat kódovat mnoho vstupních znaků na znakovou stránku a zpracovat tyto znaky pomocí více volání.Your app might need to encode many input characters to a code page and process the characters using multiple calls. V takovém případě pravděpodobně budete muset zachovat stav mezi voláními, přičemž Vezměte v úvahu stav, který je trvale Encoder použitým objektem.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Pokud vaše aplikace zpracovává vstupy ze znaků, GetBytes je doporučena verze rozpětí.If your app handles span of characters inputs, the span version of GetBytes is recommended.

  • Zvažte použití Encoder.Convert metody místo GetByteCount .Consider using the Encoder.Convert method instead of GetByteCount. Metoda převodu převede co nejvíc dat a vyvolá výjimku, pokud výstupní vyrovnávací paměť je příliš malá.The conversion method converts as much data as possible, and does throw an exception if the output span buffer is too small. Pro průběžné kódování datového proudu je tato metoda často nejlepší volbou.For continuous encoding of a stream, this method is often the best choice.

Platí pro

Produkt Introduced

GetByteCount(Char[])

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných pomocí kódování všech znaků v zadaném poli znaků.When overridden in a derived class, calculates the number of bytes produced by encoding all the characters in the specified character array.

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

Parametry

chars
Char[]

Pole znaků obsahující znaky, které mají být zakódovány.The character array containing the characters to encode.

Návraty

Int32

Počet bajtů vyprodukovaných kódováním všech znaků v zadaném poli znaků.The number of bytes produced by encoding all the characters in the specified character array.

Výjimky

chars je null.chars is null.

Došlo k chybě Fallback (Další informace najdete v tématu kódování znaků v rozhraní .NET).A fallback occurred (for more information, see Character Encoding in .NET)

ani-and-

EncoderFallback je nastaven na EncoderExceptionFallback .EncoderFallback is set to EncoderExceptionFallback.

Příklady

Následující příklad určuje počet bajtů potřebných ke kódování pole znaků, kódování znaků a zobrazení výsledných bajtů.The following example determines the number of bytes required to encode a character array, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( array<Char>^chars, Encoding^ enc );
void PrintHexBytes( array<Byte>^bytes );
int main()
{
   
   // The characters to encode:
   //    Latin Small Letter Z (U+007A)
   //    Latin Small Letter A (U+0061)
   //    Combining Breve (U+0306)
   //    Latin Small Letter AE With Acute (U+01FD)
   //    Greek Small Letter Beta (U+03B2)
   //    a high-surrogate value (U+D8FF)
   //    a low-surrogate value (U+DCFF)
   array<Char>^myChars = gcnew array<Char>{
      L'z','a',L'\u0306',L'\u01FD',L'\u03B2',L'\xD8FF',L'\xDCFF'
   };
   
   // Get different encodings.
   Encoding^ u7 = Encoding::UTF7;
   Encoding^ u8 = Encoding::UTF8;
   Encoding^ u16LE = Encoding::Unicode;
   Encoding^ u16BE = Encoding::BigEndianUnicode;
   Encoding^ u32 = Encoding::UTF32;
   
   // Encode the entire array, and print out the counts and the resulting bytes.
   PrintCountsAndBytes( myChars, u7 );
   PrintCountsAndBytes( myChars, u8 );
   PrintCountsAndBytes( myChars, u16LE );
   PrintCountsAndBytes( myChars, u16BE );
   PrintCountsAndBytes( myChars, u32 );
}

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

void PrintHexBytes( array<Byte>^bytes )
{
   if ( (bytes == nullptr) || (bytes->Length == 0) )
      Console::WriteLine( "<none>" );
   else
   {
      for ( int i = 0; i < bytes->Length; i++ )
         Console::Write( "{0:X2} ", bytes[ i ] );
      Console::WriteLine();
   }
}

/* 
This code produces the following output.

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

*/
using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

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

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

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

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

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

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

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

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

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

   public static void PrintHexBytes( byte[] bytes )  {

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


/* 
This code produces the following output.

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

*/
Imports System.Text

Public Class SamplesEncoding   

   Public Shared Sub Main()

      ' The characters to encode:
      '    Latin Small Letter Z (U+007A)
      '    Latin Small Letter A (U+0061)
      '    Combining Breve (U+0306)
      '    Latin Small Letter AE With Acute (U+01FD)
      '    Greek Small Letter Beta (U+03B2)
      '    a high-surrogate value (U+D8FF)
      '    a low-surrogate value (U+DCFF)
      Dim myChars() As Char = {"z"c, "a"c, ChrW(&H0306), ChrW(&H01FD), ChrW(&H03B2), ChrW(&HD8FF), ChrW(&HDCFF)}
 

      ' Get different encodings.
      Dim u7 As Encoding = Encoding.UTF7
      Dim u8 As Encoding = Encoding.UTF8
      Dim u16LE As Encoding = Encoding.Unicode
      Dim u16BE As Encoding = Encoding.BigEndianUnicode
      Dim u32 As Encoding = Encoding.UTF32

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

   End Sub


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

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

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

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

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

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   Public Shared Sub PrintHexBytes(bytes() As Byte)

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

   End Sub

End Class


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

Poznámky

Chcete-li vypočítat přesnou velikost pole požadovanou GetBytes pro uložení výsledných bajtů, zavolejte GetByteCount metodu.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Chcete-li vypočítat maximální velikost pole, zavolejte GetMaxByteCount metodu.To calculate the maximum array size, call the GetMaxByteCount method. GetByteCountMetoda obecně umožňuje přidělení méně paměti, zatímco GetMaxByteCount metoda se obvykle provádí rychleji.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

GetByteCountMetoda určuje, kolik bajtů má za následek kódování sady znaků Unicode a GetBytes Metoda provede skutečné kódování.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. GetBytesMetoda očekává diskrétní převody na rozdíl od Encoder.GetBytes metody, která zpracovává více převodů v jednom vstupním datovém proudu.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

GetByteCountPodporuje se několik verzí a GetBytes .Several versions of GetByteCount and GetBytes are supported. Níže jsou uvedeny některé pokyny k programování pro použití těchto metod:The following are some programming considerations for use of these methods:

  • Vaše aplikace může potřebovat kódovat mnoho vstupních znaků na znakovou stránku a zpracovat tyto znaky pomocí více volání.Your app might need to encode many input characters to a code page and process the characters using multiple calls. V takovém případě pravděpodobně budete muset zachovat stav mezi voláními, přičemž Vezměte v úvahu stav, který je trvale Encoder použitým objektem.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Pokud vaše aplikace zpracovává vstupy řetězců, měli byste použít řetězcové verze GetBytes metody.If your app handles string inputs, you should use the string versions of the GetBytes method.

  • Verze vyrovnávací paměti znaků Unicode GetBytes(Char*, Int32, Byte*, Int32) umožňuje některé rychlé techniky, zejména s více voláními pomocí Encoder objektu nebo vložení do existujících vyrovnávacích pamětí.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. Pamatujte však, že tato verze metody je někdy nebezpečná, protože jsou vyžadovány ukazatele.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Pokud vaše aplikace musí převést velké množství dat, měli byste znovu použít výstupní vyrovnávací paměť.If your app must convert a large amount of data, you should reuse the output buffer. V takovém případě GetBytes je nejlepší volbou verze, která podporuje pole bajtů.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Zvažte použití Encoder.Convert metody místo GetByteCount .Consider using the Encoder.Convert method instead of GetByteCount. Metoda převodu převede co nejvíce dat a vyvolá výjimku, pokud výstupní vyrovnávací paměť je příliš malá.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Pro průběžné kódování datového proudu je tato metoda často nejlepší volbou.For continuous encoding of a stream, this method is often the best choice.

Viz také

Platí pro

Produkt Introduced

GetByteCount(String)

Při přepsání v odvozené třídě vypočítá počet bajtů vyprodukovaných kódováním znaků v zadaném řetězci.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified string.

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

Parametry

s
String

Řetězec obsahující sadu znaků, které mají být zakódovány.The string containing the set of characters to encode.

Návraty

Int32

Počet bajtů vyprodukovaných kódováním zadaných znaků.The number of bytes produced by encoding the specified characters.

Výjimky

s je null.s is null.

Došlo k chybě Fallback (Další informace najdete v tématu kódování znaků v rozhraní .NET).A fallback occurred (for more information, see Character Encoding in .NET)

ani-and-

EncoderFallback je nastaven na EncoderExceptionFallback .EncoderFallback is set to EncoderExceptionFallback.

Příklady

Následující příklad určuje počet bajtů potřebných ke kódování řetězce nebo rozsah v řetězci, kódování znaků a zobrazení výsledných bajtů.The following example determines the number of bytes required to encode a string or a range in the string, encodes the characters, and displays the resulting bytes.

using namespace System;
using namespace System::Text;
void PrintCountsAndBytes( String^ s, Encoding^ enc );
void PrintCountsAndBytes( String^ s, int index, int count, Encoding^ enc );
void PrintHexBytes( array<Byte>^bytes );
int main()
{
   
   // The characters to encode:
   //    Latin Small Letter Z (U+007A)
   //    Latin Small Letter A (U+0061)
   //    Combining Breve (U+0306)
   //    Latin Small Letter AE With Acute (U+01FD)
   //    Greek Small Letter Beta (U+03B2)
   //    a high-surrogate value (U+D8FF)
   //    a low-surrogate value (U+DCFF)
   String^ myStr = L"za\u0306\u01FD\u03B2\xD8FF\xDCFF";
   
   // Get different encodings.
   Encoding^ u7 = Encoding::UTF7;
   Encoding^ u8 = Encoding::UTF8;
   Encoding^ u16LE = Encoding::Unicode;
   Encoding^ u16BE = Encoding::BigEndianUnicode;
   Encoding^ u32 = Encoding::UTF32;
   
   // Encode the entire string, and print out the counts and the resulting bytes.
   Console::WriteLine( "Encoding the entire string:" );
   PrintCountsAndBytes( myStr, u7 );
   PrintCountsAndBytes( myStr, u8 );
   PrintCountsAndBytes( myStr, u16LE );
   PrintCountsAndBytes( myStr, u16BE );
   PrintCountsAndBytes( myStr, u32 );
   Console::WriteLine();
   
   // Encode three characters starting at index 4, and print out the counts and the resulting bytes.
   Console::WriteLine( "Encoding the characters from index 4 through 6:" );
   PrintCountsAndBytes( myStr, 4, 3, u7 );
   PrintCountsAndBytes( myStr, 4, 3, u8 );
   PrintCountsAndBytes( myStr, 4, 3, u16LE );
   PrintCountsAndBytes( myStr, 4, 3, u16BE );
   PrintCountsAndBytes( myStr, 4, 3, u32 );
}

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

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

void PrintHexBytes( array<Byte>^bytes )
{
   if ( (bytes == nullptr) || (bytes->Length == 0) )
      Console::WriteLine( "<none>" );
   else
   {
      for ( int i = 0; i < bytes->Length; i++ )
         Console::Write( "{0:X2} ", bytes[ i ] );
      Console::WriteLine();
   }
}

/* 
This code produces the following output.

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

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

*/
using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

      // The characters to encode:
      //    Latin Small Letter Z (U+007A)
      //    Latin Small Letter A (U+0061)
      //    Combining Breve (U+0306)
      //    Latin Small Letter AE With Acute (U+01FD)
      //    Greek Small Letter Beta (U+03B2)
      //    a high-surrogate value (U+D8FF)
      //    a low-surrogate value (U+DCFF)
      String myStr = "za\u0306\u01FD\u03B2\uD8FF\uDCFF";

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

      // Encode the entire string, and print out the counts and the resulting bytes.
      Console.WriteLine( "Encoding the entire string:" );
      PrintCountsAndBytes( myStr, u7 );
      PrintCountsAndBytes( myStr, u8 );
      PrintCountsAndBytes( myStr, u16LE );
      PrintCountsAndBytes( myStr, u16BE );
      PrintCountsAndBytes( myStr, u32 );

      Console.WriteLine();

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

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

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

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

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

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

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

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

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

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

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

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

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

   public static void PrintHexBytes( byte[] bytes )  {

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


/* 
This code produces the following output.

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

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

*/
Imports System.Text

Public Class SamplesEncoding   

   Public Shared Sub Main()

      ' The characters to encode:
      '    Latin Small Letter Z (U+007A)
      '    Latin Small Letter A (U+0061)
      '    Combining Breve (U+0306)
      '    Latin Small Letter AE With Acute (U+01FD)
      '    Greek Small Letter Beta (U+03B2)
      '    a high-surrogate value (U+D8FF)
      '    a low-surrogate value (U+DCFF)
      Dim myStr As String = "za" & ChrW(&H0306) & ChrW(&H01FD) & ChrW(&H03B2) & ChrW(&HD8FF) & ChrW(&HDCFF)

      ' Get different encodings.
      Dim u7 As Encoding = Encoding.UTF7
      Dim u8 As Encoding = Encoding.UTF8
      Dim u16LE As Encoding = Encoding.Unicode
      Dim u16BE As Encoding = Encoding.BigEndianUnicode
      Dim u32 As Encoding = Encoding.UTF32

      ' Encode the entire string, and print out the counts and the resulting bytes.
      Console.WriteLine("Encoding the entire string:")
      PrintCountsAndBytes(myStr, u7)
      PrintCountsAndBytes(myStr, u8)
      PrintCountsAndBytes(myStr, u16LE)
      PrintCountsAndBytes(myStr, u16BE)
      PrintCountsAndBytes(myStr, u32)

      Console.WriteLine()

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

   End Sub


   Overloads Public Shared Sub PrintCountsAndBytes(s As String, enc As Encoding)

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

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

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

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

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   Overloads Public Shared Sub PrintCountsAndBytes(s As String, index As Integer, count As Integer, enc As Encoding)

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

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

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

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

      ' Display all the encoded bytes.
      PrintHexBytes(bytes)

   End Sub


   Public Shared Sub PrintHexBytes(bytes() As Byte)

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

   End Sub

End Class


'This code produces the following output.
'
'Encoding the entire string:
'System.Text.UTF7Encoding       : 18  23  :7A 61 2B 41 77 59 42 2F 51 4F 79 32 50 2F 63 2F 77 2D
'System.Text.UTF8Encoding       : 12  24  :7A 61 CC 86 C7 BD CE B2 F1 8F B3 BF
'System.Text.UnicodeEncoding    : 14  16  :7A 00 61 00 06 03 FD 01 B2 03 FF D8 FF DC
'System.Text.UnicodeEncoding    : 14  16  :00 7A 00 61 03 06 01 FD 03 B2 D8 FF DC FF
'System.Text.UTF32Encoding      : 24  32  :7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00 FF FC 04 00
'
'Encoding the characters from index 4 through 6:
'System.Text.UTF7Encoding       : 10  11  :2B 41 37 4C 59 2F 39 7A 2F 2D
'System.Text.UTF8Encoding       : 6   12  :CE B2 F1 8F B3 BF
'System.Text.UnicodeEncoding    : 6   8   :B2 03 FF D8 FF DC
'System.Text.UnicodeEncoding    : 6   8   :03 B2 D8 FF DC FF
'System.Text.UTF32Encoding      : 8   16  :B2 03 00 00 FF FC 04 00

Poznámky

Chcete-li vypočítat přesnou velikost pole požadovanou GetBytes pro uložení výsledných bajtů, zavolejte GetByteCount metodu.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Chcete-li vypočítat maximální velikost pole, zavolejte GetMaxByteCount metodu.To calculate the maximum array size, call the GetMaxByteCount method. GetByteCountMetoda obecně umožňuje přidělení méně paměti, zatímco GetMaxByteCount metoda se obvykle provádí rychleji.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

GetByteCountMetoda určuje, kolik bajtů má za následek kódování sady znaků Unicode a GetBytes Metoda provede skutečné kódování.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. GetBytesMetoda očekává diskrétní převody na rozdíl od Encoder.GetBytes metody, která zpracovává více převodů v jednom vstupním datovém proudu.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

GetByteCountPodporuje se několik verzí a GetBytes .Several versions of GetByteCount and GetBytes are supported. Níže jsou uvedeny některé pokyny k programování pro použití těchto metod:The following are some programming considerations for use of these methods:

  • Vaše aplikace může potřebovat kódovat mnoho vstupních znaků na znakovou stránku a zpracovat tyto znaky pomocí více volání.Your app might need to encode many input characters to a code page and process the characters using multiple calls. V takovém případě pravděpodobně budete muset zachovat stav mezi voláními, přičemž Vezměte v úvahu stav, který je trvale Encoder použitým objektem.In this case, you probably need to maintain state between calls, taking into account the state that is persisted by the Encoder object being used.

  • Pokud vaše aplikace zpracovává vstupy řetězců, GetBytes je doporučena verze řetězce.If your app handles string inputs, the string version of GetBytes is recommended.

  • Verze vyrovnávací paměti znaků Unicode GetBytes(Char*, Int32, Byte*, Int32) umožňuje některé rychlé techniky, zejména s více voláními pomocí Encoder objektu nebo vložení do existujících vyrovnávacích pamětí.The Unicode character buffer version of GetBytes(Char*, Int32, Byte*, Int32) allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. Pamatujte však, že tato verze metody je někdy nebezpečná, protože jsou vyžadovány ukazatele.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Pokud vaše aplikace musí převést velké množství dat, měla by znovu použít výstupní vyrovnávací paměť.If your app must convert a large amount of data, it should reuse the output buffer. V takovém případě GetBytes je nejlepší volbou verze, která podporuje pole bajtů.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Zvažte použití Encoder.Convert metody místo GetByteCount .Consider using the Encoder.Convert method instead of GetByteCount. Metoda převodu převede co nejvíce dat a vyvolá výjimku, pokud výstupní vyrovnávací paměť je příliš malá.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Pro průběžné kódování datového proudu je tato metoda často nejlepší volbou.For continuous encoding of a stream, this method is often the best choice.

Viz také

Platí pro

Produkt Introduced