Encoding.GetByteCount Encoding.GetByteCount Encoding.GetByteCount Encoding.GetByteCount Method

Definition

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen erzeugt werden.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters.

Überlädt

GetByteCount(String, Int32, Int32) GetByteCount(String, Int32, Int32) GetByteCount(String, Int32, Int32) GetByteCount(String, Int32, Int32)
GetByteCount(Char[], Int32, Int32) GetByteCount(Char[], Int32, Int32) GetByteCount(Char[], Int32, Int32) GetByteCount(Char[], Int32, Int32)

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen aus dem angegebenen Zeichenarray erzeugt werden.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified character array.

GetByteCount(Char*, Int32) GetByteCount(Char*, Int32) GetByteCount(Char*, Int32)

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Bytes, die beim Codieren der Zeichen ab dem Zeichenzeiger erzeugt werden.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.

GetByteCount(String) GetByteCount(String) GetByteCount(String) GetByteCount(String)

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Bytes, die beim Codieren der Zeichen in der angegebenen Zeichenfolge erzeugt werden.When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified string.

GetByteCount(ReadOnlySpan<Char>) GetByteCount(ReadOnlySpan<Char>) GetByteCount(ReadOnlySpan<Char>) GetByteCount(ReadOnlySpan<Char>)
GetByteCount(Char[]) GetByteCount(Char[]) GetByteCount(Char[]) GetByteCount(Char[])

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren aller Zeichen im angegebenen Zeichenarray erzeugt werden.When overridden in a derived class, calculates the number of bytes produced by encoding all the characters in the specified character array.

GetByteCount(String, Int32, Int32) GetByteCount(String, Int32, Int32) GetByteCount(String, Int32, Int32) GetByteCount(String, Int32, Int32)

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

Parameter

Gibt zurück

GetByteCount(Char[], Int32, Int32) GetByteCount(Char[], Int32, Int32) GetByteCount(Char[], Int32, Int32) GetByteCount(Char[], Int32, Int32)

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen aus dem angegebenen Zeichenarray erzeugt werden.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

Parameter

chars
Char[]

Das Zeichenarray, das die zu codierenden Zeichen enthält.The character array containing the set of characters to encode.

index
Int32 Int32 Int32 Int32

Der Index des ersten zu codierenden Zeichens.The index of the first character to encode.

count
Int32 Int32 Int32 Int32

Die Anzahl der zu codierenden Zeichen.The number of characters to encode.

Gibt zurück

Die Anzahl der Bytes, die beim Codieren der angegebenen Zeichen erzeugt werden.The number of bytes produced by encoding the specified characters.

Ausnahmen

index oder count ist kleiner als 0.index or count is less than zero.

- oder --or- index und count geben keinen gültigen Bereich in chars an.index and count do not denote a valid range in chars.

Ein Fallback ist aufgetreten (eine ausführliche Erläuterung finden Sie unter Zeichencodierung in .NET)A fallback occurred (see Character Encoding in .NET for complete explanation) - und --and- Für EncoderFallback ist EncoderExceptionFallback festgelegt.EncoderFallback is set to EncoderExceptionFallback.

Beispiele

Im folgenden Beispiel wird die Anzahl der Bytes festgelegt, die erforderlich sind, um drei Zeichen aus einem Zeichen Array zu codieren, die Zeichen zu codieren und die resultierenden Bytes anzeigen.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

Hinweise

Um die genaue Array Größe GetBytes zu berechnen, die zum Speichern der resultierenden Bytes erforderlich ist, müssen Sie die GetByteCount -Methode aufzurufen.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Um die maximale Array Größe zu berechnen, müssen GetMaxByteCount Sie die-Methode aufzurufen.To calculate the maximum array size, call the GetMaxByteCount method. Die GetByteCount -Methode ermöglicht im Allgemeinen die Zuordnung von weniger Arbeits GetMaxByteCount Speicher, während die-Methode im Allgemeinen schneller ausgeführt wird.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

Die GetByteCount -Methode bestimmt, wie viele Bytes zum Codieren eines Satzes von Unicode-Zeichen GetBytes führen, und die-Methode führt die eigentliche Codierung aus.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. Die GetBytes -Methode erwartet diskrete Konvertierungen, im Gegensatz Encoder.GetBytes zur-Methode, die mehrere Konvertierungen für einen einzelnen Eingabestream verarbeitet.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Es werden mehrere GetByteCount Versionen GetBytes von und unterstützt.Several versions of GetByteCount and GetBytes are supported. Im folgenden finden Sie einige Überlegungen zur Programmierung bei der Verwendung dieser Methoden:The following are some programming considerations for use of these methods:

  • Möglicherweise muss Ihre APP viele Eingabezeichen in eine Codepage codieren und die Zeichen mithilfe mehrerer Aufrufe verarbeiten.Your app might need to encode many input characters to a code page and process the characters using multiple calls. In diesem Fall müssen Sie möglicherweise den Status zwischen den Aufrufen beibehalten und dabei den Zustand berücksichtigen, der von dem Encoder verwendeten Objekt persistent gespeichert wird.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.

  • Wenn Ihre APP Zeichen folgen Eingaben behandelt, wird die Zeichen GetBytes folgen Version von empfohlen.If your app handles string inputs, the string version of GetBytes is recommended.

  • Die Unicode-Zeichen Puffer Version GetBytes(Char*, Int32, Byte*, Int32) von ermöglicht einige schnelle Techniken, insbesondere bei mehreren aufrufen, Encoder die das-Objekt verwenden, oder beim Einfügen in vorhandene Puffer.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. Beachten Sie jedoch, dass diese Methoden Version manchmal unsicher ist, da Zeiger erforderlich sind.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Wenn Ihre APP eine große Datenmenge konvertieren muss, sollte Sie den Ausgabepuffer wieder verwenden.If your app must convert a large amount of data, it should reuse the output buffer. In diesem Fall ist die GetBytes Version, die Byte Arrays unterstützt, die beste Wahl.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Sie sollten die Encoder.Convert -Methode anstelle GetByteCountvon verwenden.Consider using the Encoder.Convert method instead of GetByteCount. Die Konvertierungsmethode konvertiert so viele Daten wie möglich, und löst eine Ausnahme aus, wenn der Ausgabepuffer zu klein ist.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Bei der kontinuierlichen Codierung eines Streams ist diese Methode oft die beste Wahl.For continuous encoding of a stream, this method is often the best choice.

Siehe auch

GetByteCount(Char*, Int32) GetByteCount(Char*, Int32) GetByteCount(Char*, Int32)

Wichtig

Diese API ist nicht CLS-kompatibel.

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Bytes, die beim Codieren der Zeichen ab dem Zeichenzeiger erzeugt werden.When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.

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

Parameter

chars
Char*

Ein Zeiger auf das erste zu codierende Zeichen.A pointer to the first character to encode.

count
Int32 Int32 Int32 Int32

Die Anzahl der zu codierenden Zeichen.The number of characters to encode.

Gibt zurück

Die Anzahl der Bytes, die beim Codieren der angegebenen Zeichen erzeugt werden.The number of bytes produced by encoding the specified characters.

Ausnahmen

Ein Fallback ist aufgetreten (eine ausführliche Erläuterung finden Sie unter Zeichencodierung in .NET)A fallback occurred (see Character Encoding in .NET for complete explanation) - und --and- Für EncoderFallback ist EncoderExceptionFallback festgelegt.EncoderFallback is set to EncoderExceptionFallback.

Hinweise

Um die genaue Array Größe GetBytes zu berechnen, die zum Speichern der resultierenden Bytes benötigt, sollten Sie die GetByteCount -Methode aufzurufen.To calculate the exact array size that GetBytes requires to store the resulting bytes, you should call the GetByteCount method. Um die maximale Array Größe zu berechnen, müssen GetMaxByteCount Sie die-Methode aufzurufen.To calculate the maximum array size, call the GetMaxByteCount method. Die GetByteCount -Methode ermöglicht im Allgemeinen die Zuordnung von weniger Arbeits GetMaxByteCount Speicher, während die-Methode im Allgemeinen schneller ausgeführt wird.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

Die GetByteCount(Char*, Int32) -Methode bestimmt, wie viele Bytes zum Codieren eines Satzes von Unicode-Zeichen GetBytes(Char*, Int32, Byte*, Int32) führen, und die-Methode führt die eigentliche Codierung aus.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. Die GetBytes -Methode erwartet diskrete Konvertierungen, im Gegensatz Encoder.GetBytes zur-Methode, die mehrere Konvertierungen für einen einzelnen Eingabestream verarbeitet.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Es werden mehrere GetByteCount Versionen GetBytes von und unterstützt.Several versions of GetByteCount and GetBytes are supported. Im folgenden finden Sie einige Überlegungen zur Verwendung dieser Methoden:The following are some considerations for using these methods:

  • Möglicherweise muss Ihre APP viele Eingabezeichen in eine Codepage codieren und die Zeichen mithilfe mehrerer Aufrufe verarbeiten.Your app may need to encode many input characters to a code page and process the characters using multiple calls. In diesem Fall müssen Sie möglicherweise den Status zwischen den Aufrufen beibehalten und dabei den Zustand berücksichtigen, der von dem Encoder verwendeten Objekt persistent gespeichert wird.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.

  • Wenn Ihre APP Zeichen folgen Eingaben behandelt, sollten Sie die Zeichen folgen Version GetBytes der-Methode verwenden.If your app handles string inputs, you should use the string version of the GetBytes method.

  • Die Unicode-Zeichen Puffer Version GetBytes von ermöglicht einige schnelle Techniken, insbesondere bei mehreren aufrufen, Encoder die das-Objekt verwenden, oder beim Einfügen in vorhandene Puffer.The Unicode character buffer version of GetBytes allows some fast techniques, particularly with multiple calls using the Encoder object or inserting into existing buffers. Beachten Sie jedoch, dass diese Methoden Version manchmal unsicher ist, da Zeiger erforderlich sind.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Wenn Ihre APP eine große Datenmenge konvertieren muss, sollte Sie den Ausgabepuffer wieder verwenden.If your app must convert a large amount of data, it should reuse the output buffer. In diesem Fall ist die GetBytes Version, die Byte Arrays unterstützt, die beste Wahl.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Sie sollten die Encoder.Convert -Methode anstelle GetByteCountvon verwenden.Consider using the Encoder.Convert method instead of GetByteCount. Die Konvertierungsmethode konvertiert so viele Daten wie möglich, und löst eine Ausnahme aus, wenn der Ausgabepuffer zu klein ist.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Bei der kontinuierlichen Codierung eines Streams ist diese Methode oft die beste Wahl.For continuous encoding of a stream, this method is often the best choice.

Sicherheit

SecurityCriticalAttribute
Erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.Requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

Siehe auch

GetByteCount(String) GetByteCount(String) GetByteCount(String) GetByteCount(String)

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Bytes, die beim Codieren der Zeichen in der angegebenen Zeichenfolge erzeugt werden.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

Parameter

s
String String String String

Die Zeichenfolge mit den zu codierenden Zeichen.The string containing the set of characters to encode.

Gibt zurück

Die Anzahl der Bytes, die beim Codieren der angegebenen Zeichen erzeugt werden.The number of bytes produced by encoding the specified characters.

Ausnahmen

Ein Fallback ist aufgetreten (eine ausführliche Erläuterung finden Sie unter Zeichencodierung in .NET)A fallback occurred (see Character Encoding in .NET for complete explanation) - und --and- Für EncoderFallback ist EncoderExceptionFallback festgelegt.EncoderFallback is set to EncoderExceptionFallback.

Beispiele

Im folgenden Beispiel wird die Anzahl der Bytes festgelegt, die erforderlich sind, um eine Zeichenfolge oder einen Bereich in der Zeichenfolge zu codieren, die Zeichen codiert und die resultierenden Bytes anzeigt.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

Hinweise

Um die genaue Array Größe GetBytes zu berechnen, die zum Speichern der resultierenden Bytes erforderlich ist, müssen Sie die GetByteCount -Methode aufzurufen.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Um die maximale Array Größe zu berechnen, müssen GetMaxByteCount Sie die-Methode aufzurufen.To calculate the maximum array size, call the GetMaxByteCount method. Die GetByteCount -Methode ermöglicht im Allgemeinen die Zuordnung von weniger Arbeits GetMaxByteCount Speicher, während die-Methode im Allgemeinen schneller ausgeführt wird.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

Die GetByteCount -Methode bestimmt, wie viele Bytes zum Codieren eines Satzes von Unicode-Zeichen GetBytes führen, und die-Methode führt die eigentliche Codierung aus.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. Die GetBytes -Methode erwartet diskrete Konvertierungen, im Gegensatz Encoder.GetBytes zur-Methode, die mehrere Konvertierungen für einen einzelnen Eingabestream verarbeitet.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Es werden mehrere GetByteCount Versionen GetBytes von und unterstützt.Several versions of GetByteCount and GetBytes are supported. Im folgenden finden Sie einige Überlegungen zur Programmierung bei der Verwendung dieser Methoden:The following are some programming considerations for use of these methods:

  • Möglicherweise muss Ihre APP viele Eingabezeichen in eine Codepage codieren und die Zeichen mithilfe mehrerer Aufrufe verarbeiten.Your app might need to encode many input characters to a code page and process the characters using multiple calls. In diesem Fall müssen Sie möglicherweise den Status zwischen den Aufrufen beibehalten und dabei den Zustand berücksichtigen, der von dem Encoder verwendeten Objekt persistent gespeichert wird.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.

  • Wenn Ihre APP Zeichen folgen Eingaben behandelt, wird die Zeichen GetBytes folgen Version von empfohlen.If your app handles string inputs, the string version of GetBytes is recommended.

  • Die Unicode-Zeichen Puffer Version GetBytes(Char*, Int32, Byte*, Int32) von ermöglicht einige schnelle Techniken, insbesondere bei mehreren aufrufen, Encoder die das-Objekt verwenden, oder beim Einfügen in vorhandene Puffer.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. Beachten Sie jedoch, dass diese Methoden Version manchmal unsicher ist, da Zeiger erforderlich sind.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Wenn Ihre APP eine große Datenmenge konvertieren muss, sollte Sie den Ausgabepuffer wieder verwenden.If your app must convert a large amount of data, it should reuse the output buffer. In diesem Fall ist die GetBytes Version, die Byte Arrays unterstützt, die beste Wahl.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Sie sollten die Encoder.Convert -Methode anstelle GetByteCountvon verwenden.Consider using the Encoder.Convert method instead of GetByteCount. Die Konvertierungsmethode konvertiert so viele Daten wie möglich, und löst eine Ausnahme aus, wenn der Ausgabepuffer zu klein ist.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Bei der kontinuierlichen Codierung eines Streams ist diese Methode oft die beste Wahl.For continuous encoding of a stream, this method is often the best choice.

Siehe auch

GetByteCount(ReadOnlySpan<Char>) GetByteCount(ReadOnlySpan<Char>) GetByteCount(ReadOnlySpan<Char>) GetByteCount(ReadOnlySpan<Char>)

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

Parameter

Gibt zurück

GetByteCount(Char[]) GetByteCount(Char[]) GetByteCount(Char[]) GetByteCount(Char[])

Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren aller Zeichen im angegebenen Zeichenarray erzeugt werden.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

Parameter

chars
Char[]

Das Zeichenarray mit den zu codierenden Zeichen.The character array containing the characters to encode.

Gibt zurück

Die Anzahl der Bytes, die durch Codieren aller Zeichen im angegebenen Zeichenarray erzeugt werden.The number of bytes produced by encoding all the characters in the specified character array.

Ausnahmen

Ein Fallback ist aufgetreten (eine ausführliche Erläuterung finden Sie unter Zeichencodierung in .NET)A fallback occurred (see Character Encoding in .NET for complete explanation) - und --and- Für EncoderFallback ist EncoderExceptionFallback festgelegt.EncoderFallback is set to EncoderExceptionFallback.

Beispiele

Im folgenden Beispiel wird die Anzahl der Bytes bestimmt, die zum Codieren eines Zeichen Arrays erforderlich sind, die Zeichen codiert und die resultierenden Bytes angezeigt werden.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

Hinweise

Um die genaue Array Größe GetBytes zu berechnen, die zum Speichern der resultierenden Bytes erforderlich ist, müssen Sie die GetByteCount -Methode aufzurufen.To calculate the exact array size required by GetBytes to store the resulting bytes, call the GetByteCount method. Um die maximale Array Größe zu berechnen, müssen GetMaxByteCount Sie die-Methode aufzurufen.To calculate the maximum array size, call the GetMaxByteCount method. Die GetByteCount -Methode ermöglicht im Allgemeinen die Zuordnung von weniger Arbeits GetMaxByteCount Speicher, während die-Methode im Allgemeinen schneller ausgeführt wird.The GetByteCount method generally allows allocation of less memory, while the GetMaxByteCount method generally executes faster.

Die GetByteCount -Methode bestimmt, wie viele Bytes zum Codieren eines Satzes von Unicode-Zeichen GetBytes führen, und die-Methode führt die eigentliche Codierung aus.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding. Die GetBytes -Methode erwartet diskrete Konvertierungen, im Gegensatz Encoder.GetBytes zur-Methode, die mehrere Konvertierungen für einen einzelnen Eingabestream verarbeitet.The GetBytes method expects discrete conversions, in contrast to the Encoder.GetBytes method, which handles multiple conversions on a single input stream.

Es werden mehrere GetByteCount Versionen GetBytes von und unterstützt.Several versions of GetByteCount and GetBytes are supported. Im folgenden finden Sie einige Überlegungen zur Programmierung bei der Verwendung dieser Methoden:The following are some programming considerations for use of these methods:

  • Möglicherweise muss Ihre APP viele Eingabezeichen in eine Codepage codieren und die Zeichen mithilfe mehrerer Aufrufe verarbeiten.Your app might need to encode many input characters to a code page and process the characters using multiple calls. In diesem Fall müssen Sie möglicherweise den Status zwischen den Aufrufen beibehalten und dabei den Zustand berücksichtigen, der von dem Encoder verwendeten Objekt persistent gespeichert wird.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.

  • Wenn Ihre APP Zeichen folgen Eingaben behandelt, sollten Sie die Zeichen folgen Versionen GetBytes der-Methode verwenden.If your app handles string inputs, you should use the string versions of the GetBytes method.

  • Die Unicode-Zeichen Puffer Version GetBytes(Char*, Int32, Byte*, Int32) von ermöglicht einige schnelle Techniken, insbesondere bei mehreren aufrufen, Encoder die das-Objekt verwenden, oder beim Einfügen in vorhandene Puffer.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. Beachten Sie jedoch, dass diese Methoden Version manchmal unsicher ist, da Zeiger erforderlich sind.Bear in mind, however, that this method version is sometimes unsafe, since pointers are required.

  • Wenn Ihre APP eine große Datenmenge konvertieren muss, sollten Sie den Ausgabepuffer wieder verwenden.If your app must convert a large amount of data, you should reuse the output buffer. In diesem Fall ist die GetBytes Version, die Byte Arrays unterstützt, die beste Wahl.In this case, the GetBytes version that supports byte arrays is the best choice.

  • Sie sollten die Encoder.Convert -Methode anstelle GetByteCountvon verwenden.Consider using the Encoder.Convert method instead of GetByteCount. Die Konvertierungsmethode konvertiert so viele Daten wie möglich, und löst eine Ausnahme aus, wenn der Ausgabepuffer zu klein ist.The conversion method converts as much data as possible, and does throw an exception if the output buffer is too small. Bei der kontinuierlichen Codierung eines Streams ist diese Methode oft die beste Wahl.For continuous encoding of a stream, this method is often the best choice.

Siehe auch

Gilt für: