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

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

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

Kodlanan ilk karakterin dizini.

count: Int32

Kodlanacak karakter sayısı.

Döndürülenler

Int32

Belirtilen karakterler kodlanarak ü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

Bir 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 gereken GetBytes 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ümesinin kaç bayt ile kodlandığını belirler ve GetBytes yöntem gerçek kodlamayı gerçekleştirir. yöntemi GetBytes , 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 GetByteCount GetBytes çeşitli sürümleri desteklenir. Bu yöntemlerin kullanımıyla ilgili programlamada dikkat edilmesi gereken bazı noktalar şunlardır:

Uygulamanızın birçok giriş karakterini bir kod sayfasına kodlaması ve karakterleri birden çok çağrı kullanarak işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı hale gelen durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.
Uygulamanız dize girişlerini işliyorsa dizesi 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, GetBytes bayt 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

Kodlanan 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

ve'nin GetByteCount GetBytes çeşitli sürümleri desteklenir. Bu yöntemlerin kullanımıyla ilgili programlamada dikkat edilmesi gereken bazı noktalar şunlardır:

Uygulamanızın birçok giriş karakterini bir kod sayfasına kodlaması ve karakterleri birden çok çağrı kullanarak işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı hale gelen durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.
Uygulamanız dize girişlerini işliyorsa dizesi 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, GetBytes bayt 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*

Kodlanan ilk karakterin işaretçisi.

count: Int32

Kodlanacak karakter sayısı.

Döndürülenler

Int32

Belirtilen karakterler kodlanarak üretilen bayt sayısı.

Öznitelikler: CLSCompliantAttribute SecurityCriticalAttribute ComVisibleAttribute

Özel durumlar

ArgumentNullException

chars, null değeridir.

ArgumentOutOfRangeException

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

EncoderFallbackException

Bir 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ümesinin kaç bayt ile kodlandığını belirler ve GetBytes(Char*, Int32, Byte*, Int32) yöntem gerçek kodlamayı gerçekleştirir. yöntemi GetBytes , 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 GetByteCount GetBytes çeşitli sürümleri desteklenir. Bu yöntemlerin kullanımıyla ilgili dikkat edilmesi gereken bazı noktalar şunlardır:

Uygulamanızın birçok giriş karakterini bir kod sayfasına kodlaması ve karakterleri birden çok çağrı kullanarak işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı hale gelen 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, GetBytes bayt 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>

Kodlanan 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 gereken GetBytes tam yayılma boyutunu hesaplamak için yöntemini çağırın GetByteCount . En büyük 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.

ve'nin GetByteCount GetBytes çeşitli sürümleri desteklenir. Bu yöntemlerin kullanımıyla ilgili programlamada dikkat edilmesi gereken bazı noktalar şunlardır:

Uygulamanızın birçok giriş karakterini bir kod sayfasına kodlaması ve karakterleri birden çok çağrı kullanarak işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı hale gelen 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

Bir 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

ve'nin GetByteCount GetBytes çeşitli sürümleri desteklenir. Bu yöntemlerin kullanımıyla ilgili programlamada dikkat edilmesi gereken bazı noktalar şunlardır:

Uygulamanızın birçok giriş karakterini bir kod sayfasına kodlaması ve karakterleri birden çok çağrı kullanarak işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı hale gelen 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, GetBytes bayt 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 karakterler kodlanarak üretilen bayt sayısı.

Özel durumlar

ArgumentNullException

s, null değeridir.

EncoderFallbackException

Bir 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 dizeyi veya dizedeki bir 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

ve'nin GetByteCount GetBytes çeşitli sürümleri desteklenir. Bu yöntemlerin kullanımıyla ilgili programlamada dikkat edilmesi gereken bazı noktalar şunlardır:

Uygulamanızın birçok giriş karakterini bir kod sayfasına kodlaması ve karakterleri birden çok çağrı kullanarak işlemesi gerekebilir. Bu durumda, kullanılan nesne tarafından Encoder kalıcı hale gelen durumu hesaba katarak çağrılar arasında durumu korumanız gerekebilir.
Uygulamanız dize girişlerini işliyorsa dizesi 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, GetBytes bayt 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

Encoding.GetByteCount Yöntem

Tanım

Aşırı Yüklemeler

GetByteCount(Char[], Int32, Int32)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

GetByteCount(String, Int32, Int32)

Parametreler

Döndürülenler

Örnekler

Açıklamalar

Şunlara uygulanır

GetByteCount(Char*, Int32)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

GetByteCount(ReadOnlySpan<Char>)

Parametreler

Döndürülenler

Açıklamalar

Şunlara uygulanır

GetByteCount(Char[])

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

GetByteCount(String)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Geri Bildirim

Ek kaynaklar