Encoding.GetByteCount Yöntem

  • Başvuru

Tanım

Ad Alanı:
System.Text
Bütünleştirilmiş Kod:
System.Text.Encoding.dll
Bütünleştirilmiş Kod:
System.Runtime.dll
Bütünleştirilmiş Kod:
mscorlib.dll
Bütünleştirilmiş Kod:
netstandard.dll

Türetilmiş bir sınıfta geçersiz kılındığında, bir karakter kümesini kodlayarak üretilen bayt sayısını hesaplar.

Aşırı Yüklemeler

GetByteCount(Char[], Int32, Int32)

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter dizisinden bir karakter kümesi kodlayarak üretilen bayt sayısını hesaplar.
GetByteCount(String, Int32, Int32)

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen dizeden bir karakter kümesi kodlayarak üretilen bayt sayısını hesaplar.
GetByteCount(Char*, Int32)

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter işaretçisinde başlayan bir karakter kümesini kodlayarak üretilen bayt sayısını hesaplar.
GetByteCount(ReadOnlySpan<Char>)

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter aralığındaki karakterleri kodlayarak üretilen bayt sayısını hesaplar.
GetByteCount(Char[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter dizisindeki tüm karakterleri kodlayarak üretilen bayt sayısını hesaplar.
GetByteCount(String)

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen dizedeki karakterleri kodlayarak üretilen bayt sayısını hesaplar.

GetByteCount(Char[], Int32, Int32)

Kaynak:
Encoding.cs
Kaynak:
Encoding.cs
Kaynak:
Encoding.cs

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter dizisinden bir karakter kümesi kodlayarak üretilen bayt sayısını hesaplar.

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

Parametreler

chars
Char[]

Kodlanması gereken karakter kümesini içeren karakter dizisi.

index
Int32

Kodlanacak ilk karakterin dizini.

count
Int32

Kodlanacak karakter sayısı.

Döndürülenler

Int32

Belirtilen karakterleri kodlayarak üretilen bayt sayısı.

Özel durumlar

ArgumentNullException

chars, null değeridir.

ArgumentOutOfRangeException

index veya count sıfırdan küçüktür.

-veya-

index ve count içinde charsgeçerli bir aralığı ifade etmeyin.

EncoderFallbackException

Geri dönüş oluştu (daha fazla bilgi için bkz. .NET'te Karakter Kodlama)

-Ve-

EncoderFallback olarak ayarlanır EncoderExceptionFallback.

Örnekler

Aşağıdaki örnek, bir karakter dizisinden üç karakteri kodlamak için gereken bayt sayısını belirler, karakterleri kodlar ve sonuçta elde edilen baytları görüntüler.

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

Açıklamalar

Sonucu elde edilen baytları depolamak için tarafından GetBytes gereken dizi boyutunu tam olarak hesaplamak için yöntemini çağırın GetByteCount . En büyük dizi boyutunu hesaplamak için yöntemini çağırın GetMaxByteCount . GetByteCount yöntemi genellikle daha az bellek ayırmaya izin verirken, GetMaxByteCount yöntem genellikle daha hızlı yürütülür.

GetByteCount yöntemi, bir Unicode karakter kümesini kodlamanın kaç baytla sonuçlandığını GetBytes belirler ve yöntem gerçek kodlamayı gerçekleştirir. GetBytes yöntemi, tek bir giriş akışında birden çok dönüştürmeyi işleyen yöntemin Encoder.GetBytes aksine ayrı dönüştürmeler bekler.

ve'nin GetByteCountGetBytes çeşitli sürümleri desteklenir. Aşağıdakiler, bu yöntemlerin kullanımı için programlamada dikkat edilmesi gereken bazı noktalardır:

  • Uygulamanızın bir kod sayfasına birçok giriş karakteri kodlaması ve birden çok çağrı kullanarak karakterleri işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı olan durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.

  • Uygulamanız dize girişlerini işliyorsa, dize sürümü GetBytes önerilir.

  • Unicode karakter arabelleği sürümü GetBytes(Char*, Int32, Byte*, Int32) , özellikle nesneyi kullanan Encoder veya var olan arabelleklere eklenen birden çok çağrıda bazı hızlı tekniklere izin verir. Bununla birlikte, işaretçiler gerekli olduğundan bu yöntem sürümünün bazen güvenli olmadığını unutmayın.

  • Uygulamanızın büyük miktarda veriyi dönüştürmesi gerekiyorsa çıkış arabelleği yeniden kullanılmalıdır. Bu durumda bayt GetBytes dizilerini destekleyen sürüm en iyi seçenektir.

  • yerine GetByteCountyöntemini kullanmayı Encoder.Convert göz önünde bulundurun. Dönüştürme yöntemi mümkün olduğunca çok veriyi dönüştürür ve çıkış arabelleği çok küçükse bir özel durum oluşturur. Bir akışın sürekli kodlaması için bu yöntem genellikle en iyi seçenektir.

Ayrıca bkz.

Şunlara uygulanır

GetByteCount(String, Int32, Int32)

Kaynak:
Encoding.cs
Kaynak:
Encoding.cs
Kaynak:
Encoding.cs

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen dizeden bir karakter kümesi kodlayarak üretilen bayt sayısını hesaplar.

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

Parametreler

s
String

Kodlanması gereken karakter kümesini içeren dize.

index
Int32

Kodlanacak ilk karakterin dizini.

count
Int32

Kodlanacak karakter sayısı.

Döndürülenler

Int32

Dizeyi kodlayarak üretilen bayt sayısı.

Örnekler

Aşağıdaki örnek, bir karakter dizisinden üç karakteri kodlamak için gereken bayt sayısını belirler, karakterleri kodlar ve sonuçta elde edilen baytları görüntüler.

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

Açıklamalar

Sonucu elde edilen baytları depolamak için tarafından GetBytes gereken dizi boyutunu tam olarak hesaplamak için yöntemini çağırın GetByteCount . En büyük dizi boyutunu hesaplamak için yöntemini çağırın GetMaxByteCount . GetByteCount yöntemi genellikle daha az bellek ayırmaya izin verirken, GetMaxByteCount yöntem genellikle daha hızlı yürütülür.

GetByteCount yöntemi, bir Unicode karakter kümesini kodlamanın kaç baytla sonuçlandığını GetBytes belirler ve yöntem gerçek kodlamayı gerçekleştirir. GetBytes yöntemi, tek bir giriş akışında birden çok dönüştürmeyi işleyen yöntemin Encoder.GetBytes aksine ayrı dönüştürmeler bekler.

ve'nin GetByteCountGetBytes çeşitli sürümleri desteklenir. Aşağıdakiler, bu yöntemlerin kullanımı için programlamada dikkat edilmesi gereken bazı noktalardır:

  • Uygulamanızın bir kod sayfasına birçok giriş karakteri kodlaması ve birden çok çağrı kullanarak karakterleri işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı olan durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.

  • Uygulamanız dize girişlerini işliyorsa, dize sürümü GetBytes önerilir.

  • Unicode karakter arabelleği sürümü GetBytes(Char*, Int32, Byte*, Int32) , özellikle nesneyi kullanan Encoder veya var olan arabelleklere eklenen birden çok çağrıda bazı hızlı tekniklere izin verir. Bununla birlikte, işaretçiler gerekli olduğundan bu yöntem sürümünün bazen güvenli olmadığını unutmayın.

  • Uygulamanızın büyük miktarda veriyi dönüştürmesi gerekiyorsa çıkış arabelleği yeniden kullanılmalıdır. Bu durumda bayt GetBytes dizilerini destekleyen sürüm en iyi seçenektir.

  • yerine GetByteCountyöntemini kullanmayı Encoder.Convert göz önünde bulundurun. Dönüştürme yöntemi mümkün olduğunca çok veriyi dönüştürür ve çıkış arabelleği çok küçükse bir özel durum oluşturur. Bir akışın sürekli kodlaması için bu yöntem genellikle en iyi seçenektir.

Şunlara uygulanır

GetByteCount(Char*, Int32)

Kaynak:
Encoding.cs
Kaynak:
Encoding.cs
Kaynak:
Encoding.cs

Önemli

Bu API, CLS uyumlu değildir.

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter işaretçisinde başlayan bir karakter kümesini kodlayarak üretilen bayt sayısını hesaplar.

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

Parametreler

chars
Char*

Kodlanacak ilk karakterin işaretçisi.

count
Int32

Kodlanacak karakter sayısı.

Döndürülenler

Int32

Belirtilen karakterleri kodlayarak üretilen bayt sayısı.

Öznitelikler
CLSCompliantAttribute SecurityCriticalAttribute ComVisibleAttribute

Özel durumlar

ArgumentNullException

chars, null değeridir.

ArgumentOutOfRangeException

count, sıfırdan küçüktür.

EncoderFallbackException

Geri dönüş oluştu (daha fazla bilgi için bkz. .NET'te Karakter Kodlama)

-Ve-

EncoderFallback olarak ayarlanır EncoderExceptionFallback.

Açıklamalar

Elde edilen baytların depolanmasını gerektiren GetBytes dizi boyutunu tam olarak hesaplamak için yöntemini çağırmanız GetByteCount gerekir. En büyük dizi boyutunu hesaplamak için yöntemini çağırın GetMaxByteCount . GetByteCount yöntemi genellikle daha az bellek ayırmaya izin verirken, GetMaxByteCount yöntem genellikle daha hızlı yürütülür.

GetByteCount(Char*, Int32) yöntemi, bir Unicode karakter kümesini kodlamanın kaç baytla sonuçlandığını GetBytes(Char*, Int32, Byte*, Int32) belirler ve yöntem gerçek kodlamayı gerçekleştirir. GetBytes yöntemi, tek bir giriş akışında birden çok dönüştürmeyi işleyen yöntemin Encoder.GetBytes aksine ayrı dönüştürmeler bekler.

ve'nin GetByteCountGetBytes çeşitli sürümleri desteklenir. Aşağıdakiler, bu yöntemlerin kullanılmasıyla ilgili dikkat edilmesi gereken bazı noktalardır:

  • Uygulamanızın bir kod sayfasına birçok giriş karakteri kodlaması ve birden çok çağrı kullanarak karakterleri işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı olan durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.

  • Uygulamanız dize girişlerini işleyecekse yönteminin dize sürümünü GetBytes kullanmanız gerekir.

  • Unicode karakter arabelleği sürümü GetBytes , özellikle nesneyi kullanan Encoder veya var olan arabelleklere eklenen birden çok çağrıda bazı hızlı tekniklere izin verir. Bununla birlikte, işaretçiler gerekli olduğundan bu yöntem sürümünün bazen güvenli olmadığını unutmayın.

  • Uygulamanızın büyük miktarda veriyi dönüştürmesi gerekiyorsa çıkış arabelleği yeniden kullanılmalıdır. Bu durumda bayt GetBytes dizilerini destekleyen sürüm en iyi seçenektir.

  • yerine GetByteCountyöntemini kullanmayı Encoder.Convert göz önünde bulundurun. Dönüştürme yöntemi mümkün olduğunca çok veriyi dönüştürür ve çıkış arabelleği çok küçükse bir özel durum oluşturur. Bir akışın sürekli kodlaması için bu yöntem genellikle en iyi seçenektir.

Ayrıca bkz.

Şunlara uygulanır

GetByteCount(ReadOnlySpan<Char>)

Kaynak:
Encoding.cs
Kaynak:
Encoding.cs
Kaynak:
Encoding.cs

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter aralığındaki karakterleri kodlayarak üretilen bayt sayısını hesaplar.

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

Parametreler

chars
ReadOnlySpan<Char>

Kodlanacak karakterlerin yayılması.

Döndürülenler

Int32

Belirtilen karakter aralığını kodlayarak üretilen bayt sayısı.

Açıklamalar

Sonucu elde edilen baytları depolamak için tarafından GetBytes gereken tam yayılma boyutunu hesaplamak için yöntemini çağırın GetByteCount . Maksimum yayılma boyutunu hesaplamak için yöntemini çağırın GetMaxByteCount . GetByteCount yöntemi genellikle daha az bellek ayırmaya izin verirken, GetMaxByteCount yöntem genellikle daha hızlı yürütülür.

GetByteCount yöntemi, bir Unicode karakter kümesini kodlamanın kaç baytla sonuçlandığını GetBytes belirler ve yöntem gerçek kodlamayı gerçekleştirir. GetBytes yöntemi, tek bir giriş akışında birden çok dönüştürmeyi işleyen yöntemin Encoder.GetBytes aksine ayrı dönüştürmeler bekler.

ve'nin GetByteCountGetBytes çeşitli sürümleri desteklenir. Aşağıdakiler, bu yöntemlerin kullanımı için programlamada dikkat edilmesi gereken bazı noktalardır:

  • Uygulamanızın bir kod sayfasına birçok giriş karakteri kodlaması ve birden çok çağrı kullanarak karakterleri işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı olan durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.

  • Uygulamanız karakter girişlerinin aralığını işliyorsa, span sürümü GetBytes önerilir.

  • yerine GetByteCountyöntemini kullanmayı Encoder.Convert göz önünde bulundurun. Dönüştürme yöntemi mümkün olduğunca çok veriyi dönüştürür ve çıkış aralığı arabelleği çok küçükse bir özel durum oluşturur. Bir akışın sürekli kodlaması için bu yöntem genellikle en iyi seçenektir.

Şunlara uygulanır

GetByteCount(Char[])

Kaynak:
Encoding.cs
Kaynak:
Encoding.cs
Kaynak:
Encoding.cs

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen karakter dizisindeki tüm karakterleri kodlayarak üretilen bayt sayısını hesaplar.

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

Parametreler

chars
Char[]

Kodlanması gereken karakterleri içeren karakter dizisi.

Döndürülenler

Int32

Belirtilen karakter dizisindeki tüm karakterleri kodlayarak üretilen bayt sayısı.

Özel durumlar

ArgumentNullException

chars, null değeridir.

EncoderFallbackException

Geri dönüş oluştu (daha fazla bilgi için bkz. .NET'te Karakter Kodlama)

-Ve-

EncoderFallback olarak ayarlanır EncoderExceptionFallback.

Örnekler

Aşağıdaki örnek, bir karakter dizisini kodlamak için gereken bayt sayısını belirler, karakterleri kodlar ve sonuçta elde edilen baytları görüntüler.

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

Açıklamalar

Sonucu elde edilen baytları depolamak için tarafından GetBytes gereken dizi boyutunu tam olarak hesaplamak için yöntemini çağırın GetByteCount . En büyük dizi boyutunu hesaplamak için yöntemini çağırın GetMaxByteCount . GetByteCount yöntemi genellikle daha az bellek ayırmaya izin verirken, GetMaxByteCount yöntem genellikle daha hızlı yürütülür.

GetByteCount yöntemi, bir Unicode karakter kümesini kodlamanın kaç baytla sonuçlandığını GetBytes belirler ve yöntem gerçek kodlamayı gerçekleştirir. GetBytes yöntemi, tek bir giriş akışında birden çok dönüştürmeyi işleyen yöntemin Encoder.GetBytes aksine ayrı dönüştürmeler bekler.

ve'nin GetByteCountGetBytes çeşitli sürümleri desteklenir. Aşağıdakiler, bu yöntemlerin kullanımı için programlamada dikkat edilmesi gereken bazı noktalardır:

  • Uygulamanızın bir kod sayfasına birçok giriş karakteri kodlaması ve birden çok çağrı kullanarak karakterleri işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı olan durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.

  • Uygulamanız dize girişlerini işleyecekse yönteminin dize sürümlerini GetBytes kullanmanız gerekir.

  • Unicode karakter arabelleği sürümü GetBytes(Char*, Int32, Byte*, Int32) , özellikle nesneyi kullanan Encoder veya var olan arabelleklere eklenen birden çok çağrıda bazı hızlı tekniklere izin verir. Bununla birlikte, işaretçiler gerekli olduğundan bu yöntem sürümünün bazen güvenli olmadığını unutmayın.

  • Uygulamanızın büyük miktarda veriyi dönüştürmesi gerekiyorsa çıkış arabelleği yeniden kullanmanız gerekir. Bu durumda bayt GetBytes dizilerini destekleyen sürüm en iyi seçenektir.

  • yerine GetByteCountyöntemini kullanmayı Encoder.Convert göz önünde bulundurun. Dönüştürme yöntemi mümkün olduğunca çok veriyi dönüştürür ve çıkış arabelleği çok küçükse bir özel durum oluşturur. Bir akışın sürekli kodlaması için bu yöntem genellikle en iyi seçenektir.

Ayrıca bkz.

Şunlara uygulanır

GetByteCount(String)

Kaynak:
Encoding.cs
Kaynak:
Encoding.cs
Kaynak:
Encoding.cs

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen dizedeki karakterleri kodlayarak üretilen bayt sayısını hesaplar.

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

Parametreler

s
String

Kodlanması gereken karakter kümesini içeren dize.

Döndürülenler

Int32

Belirtilen karakterleri kodlayarak üretilen bayt sayısı.

Özel durumlar

ArgumentNullException

s, null değeridir.

EncoderFallbackException

Geri dönüş oluştu (daha fazla bilgi için bkz. .NET'te Karakter Kodlama)

-Ve-

EncoderFallback olarak ayarlanır EncoderExceptionFallback.

Örnekler

Aşağıdaki örnek, dizedeki bir dizeyi veya aralığı kodlamak için gereken bayt sayısını belirler, karakterleri kodlar ve sonuçta elde edilen baytları görüntüler.

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

Açıklamalar

Sonucu elde edilen baytları depolamak için tarafından GetBytes gereken dizi boyutunu tam olarak hesaplamak için yöntemini çağırın GetByteCount . En büyük dizi boyutunu hesaplamak için yöntemini çağırın GetMaxByteCount . GetByteCount yöntemi genellikle daha az bellek ayırmaya izin verirken, GetMaxByteCount yöntem genellikle daha hızlı yürütülür.

GetByteCount yöntemi, bir Unicode karakter kümesini kodlamanın kaç baytla sonuçlandığını GetBytes belirler ve yöntem gerçek kodlamayı gerçekleştirir. GetBytes yöntemi, tek bir giriş akışında birden çok dönüştürmeyi işleyen yöntemin Encoder.GetBytes aksine ayrı dönüştürmeler bekler.

ve'nin GetByteCountGetBytes çeşitli sürümleri desteklenir. Aşağıdakiler, bu yöntemlerin kullanımı için programlamada dikkat edilmesi gereken bazı noktalardır:

  • Uygulamanızın bir kod sayfasına birçok giriş karakteri kodlaması ve birden çok çağrı kullanarak karakterleri işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı olan durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.

  • Uygulamanız dize girişlerini işliyorsa, dize sürümü GetBytes önerilir.

  • Unicode karakter arabelleği sürümü GetBytes(Char*, Int32, Byte*, Int32) , özellikle nesneyi kullanan Encoder veya var olan arabelleklere eklenen birden çok çağrıda bazı hızlı tekniklere izin verir. Bununla birlikte, işaretçiler gerekli olduğundan bu yöntem sürümünün bazen güvenli olmadığını unutmayın.

  • Uygulamanızın büyük miktarda veriyi dönüştürmesi gerekiyorsa çıkış arabelleği yeniden kullanılmalıdır. Bu durumda bayt GetBytes dizilerini destekleyen sürüm en iyi seçenektir.

  • yerine GetByteCountyöntemini kullanmayı Encoder.Convert göz önünde bulundurun. Dönüştürme yöntemi mümkün olduğunca çok veriyi dönüştürür ve çıkış arabelleği çok küçükse bir özel durum oluşturur. Bir akışın sürekli kodlaması için bu yöntem genellikle en iyi seçenektir.

Ayrıca bkz.

Şunlara uygulanır