Encoding.GetChars メソッド

定義

派生クラスでオーバーライドされた場合、バイト シーケンスを文字のセットにデコードします。

オーバーロード

GetChars(Byte[], Int32, Int32, Char[], Int32)

派生クラスでオーバーライドされた場合、指定したバイト配列に格納されているバイト シーケンスを、指定した文字配列にデコードします。

GetChars(Byte*, Int32, Char*, Int32)

派生クラスでオーバーライドされた場合、指定したバイト ポインターで始まるバイト シーケンスを、指定した文字ポインターを開始位置として格納される文字のセットにデコードします。

GetChars(Byte[], Int32, Int32)

派生クラスでオーバーライドされた場合、指定したバイト配列に格納されているバイト シーケンスを文字のセットにデコードします。

GetChars(ReadOnlySpan<Byte>, Span<Char>)

派生クラスでオーバーライドされた場合、指定した読み取り専用バイト スパンに格納されているすべてのバイトを、文字スパンにデコードします。

GetChars(Byte[])

派生クラスでオーバーライドされた場合、指定したバイト配列に格納されているすべてのバイトを文字のセットにデコードします。

GetChars(Byte[], Int32, Int32, Char[], Int32)

派生クラスでオーバーライドされた場合、指定したバイト配列に格納されているバイト シーケンスを、指定した文字配列にデコードします。

public:
 abstract int GetChars(cli::array <System::Byte> ^ bytes, int byteIndex, int byteCount, cli::array <char> ^ chars, int charIndex);
public abstract int GetChars (byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex);
abstract member GetChars : byte[] * int * int * char[] * int -> int
Public MustOverride Function GetChars (bytes As Byte(), byteIndex As Integer, byteCount As Integer, chars As Char(), charIndex As Integer) As Integer

パラメーター

bytes
Byte[]

デコード対象のバイト シーケンスが格納されたバイト配列。

byteIndex
Int32

デコードする最初のバイトのインデックス。

byteCount
Int32

デコードするバイト数。

chars
Char[]

結果の文字のセットを格納する文字配列。

charIndex
Int32

結果の文字のセットを書き込む開始位置のインデックス。

戻り値

chars に書き込まれた実際の文字数。

例外

bytesnull です。

または

charsnull です。

byteIndexbyteCount、または charIndex が 0 未満です。

または

byteindex および byteCountbytesにおいて有効な範囲を表していません。

または

charIndexchars の有効なインデックスではありません。

chars には、charIndex から配列の末尾までに十分なサイズがなく、結果の文字を格納できません。

フォールバックが発生しました (詳細については「.NET での文字エンコード」を参照)

および

DecoderFallbackDecoderExceptionFallback に設定されます。

次の例では、あるエンコードから別のエンコーディングに文字列を変換します。

using namespace System;
using namespace System::Text;

int main()
{
   String^ unicodeString = "This string contains the unicode character Pi (\u03a0)";
   
   // Create two different encodings.
   Encoding^ ascii = Encoding::ASCII;
   Encoding^ unicode = Encoding::Unicode;
   
   // Convert the string into a byte array.
   array<Byte>^unicodeBytes = unicode->GetBytes( unicodeString );
   
   // Perform the conversion from one encoding to the other.
   array<Byte>^asciiBytes = Encoding::Convert( unicode, ascii, unicodeBytes );
   
   // Convert the new Byte into[] a char and[] then into a string.
   array<Char>^asciiChars = gcnew array<Char>(ascii->GetCharCount( asciiBytes, 0, asciiBytes->Length ));
   ascii->GetChars( asciiBytes, 0, asciiBytes->Length, asciiChars, 0 );
   String^ asciiString = gcnew String( asciiChars );
   
   // Display the strings created before and after the conversion.
   Console::WriteLine( "Original String*: {0}", unicodeString );
   Console::WriteLine( "Ascii converted String*: {0}", asciiString );
}
// The example displays the following output:
//    Original string: This string contains the unicode character Pi (Π)
//    Ascii converted string: This string contains the unicode character Pi (?)
using System;
using System.Text;

class Example
{
   static void Main()
   {
      string unicodeString = "This string contains the unicode character Pi (\u03a0)";

      // Create two different encodings.
      Encoding ascii = Encoding.ASCII;
      Encoding unicode = Encoding.Unicode;

      // Convert the string into a byte array.
      byte[] unicodeBytes = unicode.GetBytes(unicodeString);

      // Perform the conversion from one encoding to the other.
      byte[] asciiBytes = Encoding.Convert(unicode, ascii, unicodeBytes);
         
      // Convert the new byte[] into a char[] and then into a string.
      char[] asciiChars = new char[ascii.GetCharCount(asciiBytes, 0, asciiBytes.Length)];
      ascii.GetChars(asciiBytes, 0, asciiBytes.Length, asciiChars, 0);
      string asciiString = new string(asciiChars);

      // Display the strings created before and after the conversion.
      Console.WriteLine("Original string: {0}", unicodeString);
      Console.WriteLine("Ascii converted string: {0}", asciiString);
   }
}
// The example displays the following output:
//    Original string: This string contains the unicode character Pi (Π)
//    Ascii converted string: This string contains the unicode character Pi (?)
Imports System.Text

Class Example
   Shared Sub Main()
      Dim unicodeString As String = "This string contains the unicode character Pi (" & ChrW(&H03A0) & ")"

      ' Create two different encodings.
      Dim ascii As Encoding = Encoding.ASCII
      Dim unicode As Encoding = Encoding.Unicode

      ' Convert the string into a byte array.
      Dim unicodeBytes As Byte() = unicode.GetBytes(unicodeString)

      ' Perform the conversion from one encoding to the other.
      Dim asciiBytes As Byte() = Encoding.Convert(unicode, ascii, unicodeBytes)

      ' Convert the new byte array into a char array and then into a string.
      Dim asciiChars(ascii.GetCharCount(asciiBytes, 0, asciiBytes.Length)-1) As Char
      ascii.GetChars(asciiBytes, 0, asciiBytes.Length, asciiChars, 0)
      Dim asciiString As New String(asciiChars)

      ' Display the strings created before and after the conversion.
      Console.WriteLine("Original string: {0}", unicodeString)
      Console.WriteLine("Ascii converted string: {0}", asciiString)
   End Sub
End Class
' The example displays the following output:
'    Original string: This string contains the unicode character Pi (Π)
'    Ascii converted string: This string contains the unicode character Pi (?)

次の例では、文字列をバイト配列にエンコードした後、バイトの範囲を文字配列にデコードします。

using namespace System;
using namespace System::Text;
void PrintCountsAndChars( array<Byte>^bytes, int index, int count, Encoding^ enc );
int main()
{
   
   // Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
   Encoding^ u32LE = Encoding::GetEncoding( "utf-32" );
   Encoding^ u32BE = Encoding::GetEncoding( "utf-32BE" );
   
   // Use a string containing the following characters:
   //    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)
   String^ myStr = "za\u0306\u01FD\u03B2";
   
   // Encode the string using the big-endian byte order.
   array<Byte>^barrBE = gcnew array<Byte>(u32BE->GetByteCount( myStr ));
   u32BE->GetBytes( myStr, 0, myStr->Length, barrBE, 0 );
   
   // Encode the string using the little-endian byte order.
   array<Byte>^barrLE = gcnew array<Byte>(u32LE->GetByteCount( myStr ));
   u32LE->GetBytes( myStr, 0, myStr->Length, barrLE, 0 );
   
   // Get the char counts, decode eight bytes starting at index 0,
   // and print out the counts and the resulting bytes.
   Console::Write( "BE array with BE encoding : " );
   PrintCountsAndChars( barrBE, 0, 8, u32BE );
   Console::Write( "LE array with LE encoding : " );
   PrintCountsAndChars( barrLE, 0, 8, u32LE );
}

void PrintCountsAndChars( array<Byte>^bytes, int index, int count, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-25} :", enc );
   
   // Display the exact character count.
   int iCC = enc->GetCharCount( bytes, index, count );
   Console::Write( " {0,-3}", iCC );
   
   // Display the maximum character count.
   int iMCC = enc->GetMaxCharCount( count );
   Console::Write( " {0,-3} :", iMCC );
   
   // Decode the bytes and display the characters.
   array<Char>^chars = enc->GetChars( bytes, index, count );
   
   // The following is an alternative way to decode the bytes:
   // Char[] chars = new Char[iCC];
   // enc->GetChars( bytes, index, count, chars, 0 );
   Console::WriteLine( chars );
}

/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

BE array with BE encoding : System.Text.UTF32Encoding : 2   6   :za
LE array with LE encoding : System.Text.UTF32Encoding : 2   6   :za

*/
using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

      // Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
      Encoding u32LE = Encoding.GetEncoding( "utf-32" );
      Encoding u32BE = Encoding.GetEncoding( "utf-32BE" );

      // Use a string containing the following characters:
      //    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)
      String myStr = "za\u0306\u01FD\u03B2";

      // Encode the string using the big-endian byte order.
      byte[] barrBE = new byte[u32BE.GetByteCount( myStr )];
      u32BE.GetBytes( myStr, 0, myStr.Length, barrBE, 0 );

      // Encode the string using the little-endian byte order.
      byte[] barrLE = new byte[u32LE.GetByteCount( myStr )];
      u32LE.GetBytes( myStr, 0, myStr.Length, barrLE, 0 );

      // Get the char counts, decode eight bytes starting at index 0,
      // and print out the counts and the resulting bytes.
      Console.Write( "BE array with BE encoding : " );
      PrintCountsAndChars( barrBE, 0, 8, u32BE );
      Console.Write( "LE array with LE encoding : " );
      PrintCountsAndChars( barrLE, 0, 8, u32LE );
   }

   public static void PrintCountsAndChars( byte[] bytes, int index, int count, Encoding enc )  {

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

      // Display the exact character count.
      int iCC  = enc.GetCharCount( bytes, index, count );
      Console.Write( " {0,-3}", iCC );

      // Display the maximum character count.
      int iMCC = enc.GetMaxCharCount( count );
      Console.Write( " {0,-3} :", iMCC );

      // Decode the bytes and display the characters.
      char[] chars = enc.GetChars( bytes, index, count );

      // The following is an alternative way to decode the bytes:
      // char[] chars = new char[iCC];
      // enc.GetChars( bytes, index, count, chars, 0 );

      Console.WriteLine( chars );
   }
}


/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

BE array with BE encoding : System.Text.UTF32Encoding : 2   6   :za
LE array with LE encoding : System.Text.UTF32Encoding : 2   6   :za

*/
Imports System.Text

Public Class SamplesEncoding   

   Public Shared Sub Main()

      ' Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
      Dim u32LE As Encoding = Encoding.GetEncoding("utf-32")
      Dim u32BE As Encoding = Encoding.GetEncoding("utf-32BE")

      ' Use a string containing the following characters:
      '    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)
      Dim myStr As String = "za" & ChrW(&H0306) & ChrW(&H01FD) & ChrW(&H03B2)

      ' Encode the string using the big-endian byte order.
      ' NOTE: In VB.NET, arrays contain one extra element by default.
      '       The following line creates barrBE with the exact number of elements required.
      Dim barrBE(u32BE.GetByteCount(myStr) - 1) As Byte
      u32BE.GetBytes(myStr, 0, myStr.Length, barrBE, 0)

      ' Encode the string using the little-endian byte order.
      ' NOTE: In VB.NET, arrays contain one extra element by default.
      '       The following line creates barrLE with the exact number of elements required.
      Dim barrLE(u32LE.GetByteCount(myStr) - 1) As Byte
      u32LE.GetBytes(myStr, 0, myStr.Length, barrLE, 0)

      ' Get the char counts, decode eight bytes starting at index 0,
      ' and print out the counts and the resulting bytes.
      Console.Write("BE array with BE encoding : ")
      PrintCountsAndChars(barrBE, 0, 8, u32BE)
      Console.Write("LE array with LE encoding : ")
      PrintCountsAndChars(barrLE, 0, 8, u32LE)

   End Sub


   Public Shared Sub PrintCountsAndChars(bytes() As Byte, index As Integer, count As Integer, enc As Encoding)

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

      ' Display the exact character count.
      Dim iCC As Integer = enc.GetCharCount(bytes, index, count)
      Console.Write(" {0,-3}", iCC)

      ' Display the maximum character count.
      Dim iMCC As Integer = enc.GetMaxCharCount(count)
      Console.Write(" {0,-3} :", iMCC)

      ' Decode the bytes.
      Dim chars As Char() = enc.GetChars(bytes, index, count)

      ' The following is an alternative way to decode the bytes:
      ' 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 chars(iCC - 1) As Char
      ' enc.GetChars( bytes, index, count, chars, 0 )

      ' Display the characters.
      Console.WriteLine(chars)

   End Sub

End Class


'This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.
'
'BE array with BE encoding : System.Text.UTF32Encoding : 2   6   :za
'LE array with LE encoding : System.Text.UTF32Encoding : 2   6   :za

注釈

が結果の文字を格納するために必要な配列の正確なサイズを計算するには、 GetChars メソッドを使用する必要があり GetCharCount ます。 配列の最大サイズを計算するには、メソッドを使用し GetMaxCharCount ます。 メソッドは一般に、より GetCharCount 少ないメモリの割り当てを可能にしますが、 GetMaxCharCount メソッドは通常、より高速に実行されます。

GetChars(Byte[], Int32, Int32, Char[], Int32)入力バイトシーケンスから文字を取得します。 Encoding.GetCharsはとは Decoder.GetChars 異なり Encoding 、は不連続変換を想定し Decoder ていますが、は1つの入力ストリームに対して複数のパスを使用するように設計されています。

変換するデータが、連続したブロック (ストリームから読み取られたデータなど) でのみ使用可能な場合、またはデータの量が大きく、小さいブロックに分割する必要がある場合は、 DecoderEncoderGetDecoder 派生クラスのメソッドまたはメソッドによって提供されるまたはを使用する必要があり GetEncoder ます。

注意

このメソッドは、バイト配列などの任意のバイナリデータではなく、Unicode 文字を操作することを目的としています。 任意のバイナリデータをテキストにエンコードする必要がある場合は、uuencode などのプロトコルを使用する必要があります。これは、などのメソッドによって実装され Convert.ToBase64CharArray ます。

メソッドは、 GetCharCount バイトシーケンスをデコードする文字数を決定し、メソッドは GetChars 実際のデコードを実行します。 メソッドは、 Encoding.GetCharsDecoder.GetChars 1 つの入力ストリームに対して複数のパスを処理するメソッドとは対照的に、離散変換を必要とします。

とのいくつかのバージョン GetCharCountGetChars がサポートされています。 これらのメソッドを使用するためのプログラミング上の考慮事項を次に示します。

  • アプリでは、複数の呼び出しを使用して、コードページから複数の入力バイトをデコードし、バイトを処理することが必要になる場合があります。 この場合は、バッチ処理時にバイトシーケンスが中断される可能性があるため、呼び出し間で状態を維持する必要があります。 (たとえば、ISO-2022 シフト シーケンスの一部は、1 つの GetChars 呼び出しを終了し、次 GetChars の呼び出しの開始時に続行できます。 Encoding.GetChars これらの不完全なシーケンスのフォールバックを呼び出しますが Decoder 、次の呼び出しのシーケンスを記憶します)。

  • アプリが文字列出力を処理する場合は、メソッドを使用する GetString ことをお勧めします。 このメソッドは文字列の長さを確認してバッファーを割り当てる必要があるため、少し遅くなりますが、結果の String 型が優先されます。

  • のバイトバージョンでは GetChars(Byte*, Int32, Char*, Int32) 、特に大きなバッファーを複数回呼び出す場合に、いくつかの高速な手法が許可されます。 ただし、ポインターが必要であるため、このメソッドのバージョンは安全でない場合があることに注意してください。

  • アプリで大量のデータを変換する必要がある場合は、出力バッファーを再利用する必要があります。 この場合、 GetChars(Byte[], Int32, Int32, Char[], Int32) 出力文字バッファーをサポートするバージョンが最適な選択肢です。

  • ではなく、メソッドを使用することを検討してください Decoder.ConvertGetCharCount 。 変換メソッドは、可能な限り多くのデータを変換し、出力バッファーが小さすぎる場合は例外をスローします。 ストリームを連続してデコードする場合は、この方法が最適な選択肢です。

こちらもご覧ください

適用対象

GetChars(Byte*, Int32, Char*, Int32)

重要

この API は CLS 準拠ではありません。

派生クラスでオーバーライドされた場合、指定したバイト ポインターで始まるバイト シーケンスを、指定した文字ポインターを開始位置として格納される文字のセットにデコードします。

public:
 virtual int GetChars(System::Byte* bytes, int byteCount, char* chars, int charCount);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount);
[System.CLSCompliant(false)]
public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount);
[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
[System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount);
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int
[<System.CLSCompliant(false)>]
abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int
[<System.CLSCompliant(false)>]
[<System.Runtime.InteropServices.ComVisible(false)>]
abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
[<System.Runtime.InteropServices.ComVisible(false)>]
abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int -> int

パラメーター

bytes
Byte*

デコードする最初のバイトへのポインター。

byteCount
Int32

デコードするバイト数。

chars
Char*

結果の文字セットの書き込みを開始する位置へのポインター。

charCount
Int32

書き込む文字の最大数。

戻り値

chars パラメーターによって示される位置に書き込む実際の文字数。

属性

例外

bytesnull です。

または

charsnull です。

byteCount または charCount が 0 未満です。

charCount が結果の文字数より少なくなっています。

フォールバックが発生しました (詳細については「.NET での文字エンコード」を参照)

および

DecoderFallbackDecoderExceptionFallback に設定されます。

注釈

結果の文字を格納するために必要な配列の正確なサイズを計算するには、 GetChars メソッドを使用する必要があり GetCharCount ます。 配列の最大サイズを計算するには、メソッドを使用し GetMaxCharCount ます。 メソッドは一般に、より GetCharCount 少ないメモリの割り当てを可能にしますが、 GetMaxCharCount メソッドは通常、より高速に実行されます。

Encoding.GetChars入力バイトシーケンスから文字を取得します。 Encoding.GetCharsはとは Decoder.GetChars 異なり Encoding 、は不連続変換を想定し Decoder ていますが、は1つの入力ストリームに対して複数のパスを使用するように設計されています。

変換されるデータがストリームから読み取られたデータ) などの連続したブロック内でのみ使用可能な場合、またはデータの量が非常に大きいので、小さなブロックに分割する必要がある、使用する必要があります、DecoderまたはEncoderオブジェクト、によって提供されるGetDecoderまたはGetEncoderメソッドでは、派生クラスのそれぞれに、します。

注意

このメソッドは、バイト配列などの任意のバイナリデータではなく、Unicode 文字を操作することを目的としています。 任意のバイナリデータをテキストにエンコードする必要がある場合は、uuencode などのプロトコルを使用する必要があります。これは、などのメソッドによって実装され Convert.ToBase64CharArray ます。

メソッドは、 GetCharCount バイトシーケンスをデコードする文字数を決定し、メソッドは GetChars 実際のデコードを実行します。 メソッドは、 Encoding.GetCharsDecoder.GetChars 1 つの入力ストリームに対して複数のパスを処理するメソッドとは対照的に、離散変換を必要とします。

とのいくつかのバージョン GetCharCountGetChars がサポートされています。 これらのメソッドを使用するためのプログラミング上の考慮事項を次に示します。

  • アプリでは、複数の呼び出しを使用して、コードページから複数の入力バイトをデコードし、バイトを処理することが必要になる場合があります。 この場合は、バッチ処理時にバイトシーケンスが中断される可能性があるため、呼び出し間で状態を維持する必要があります。 (たとえば、ISO-2022 シフト シーケンスの一部は、1 つの GetChars 呼び出しを終了し、次 GetChars の呼び出しの開始時に続行できます。 Encoding.GetChars これらの不完全なシーケンスのフォールバックを呼び出しますが Decoder 、次の呼び出しのシーケンスを記憶します)。

  • アプリが文字列出力を処理する場合は、メソッドを使用する GetString ことをお勧めします。 このメソッドは文字列の長さを確認してバッファーを割り当てる必要があるため、少し遅くなりますが、結果の String 型が優先されます。

  • のバイトバージョンでは GetChars(Byte*, Int32, Char*, Int32) 、特に大きなバッファーを複数回呼び出す場合に、いくつかの高速な手法が許可されます。 ただし、ポインターが必要であるため、このメソッドのバージョンは安全でない場合があることに注意してください。

  • アプリで大量のデータを変換する必要がある場合は、出力バッファーを再利用する必要があります。 この場合、 GetChars(Byte[], Int32, Int32, Char[], Int32) 出力文字バッファーをサポートするバージョンが最適な選択肢です。

  • ではなく、メソッドを使用することを検討してください Decoder.ConvertGetCharCount 。 変換メソッドは、可能な限り多くのデータを変換し、出力バッファーが小さすぎる場合は例外をスローします。 ストリームを連続してデコードする場合は、この方法が最適な選択肢です。

こちらもご覧ください

適用対象

GetChars(Byte[], Int32, Int32)

派生クラスでオーバーライドされた場合、指定したバイト配列に格納されているバイト シーケンスを文字のセットにデコードします。

public:
 virtual cli::array <char> ^ GetChars(cli::array <System::Byte> ^ bytes, int index, int count);
public virtual char[] GetChars (byte[] bytes, int index, int count);
abstract member GetChars : byte[] * int * int -> char[]
override this.GetChars : byte[] * int * int -> char[]
Public Overridable Function GetChars (bytes As Byte(), index As Integer, count As Integer) As Char()

パラメーター

bytes
Byte[]

デコード対象のバイト シーケンスが格納されたバイト配列。

index
Int32

デコードする最初のバイトのインデックス。

count
Int32

デコードするバイト数。

戻り値

Char[]

指定したバイト シーケンスのデコード結果が格納された文字配列。

例外

bytesnull です。

index または count が 0 未満です。

または

index および countbytes において有効な範囲を表していません。

フォールバックが発生しました (詳細については「.NET での文字エンコード」を参照)

および

DecoderFallbackDecoderExceptionFallback に設定されます。

次の例では、文字列をバイト配列にエンコードした後、バイトの範囲を文字配列にデコードします。

using namespace System;
using namespace System::Text;
void PrintCountsAndChars( array<Byte>^bytes, int index, int count, Encoding^ enc );
int main()
{
   
   // Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
   Encoding^ u32LE = Encoding::GetEncoding( "utf-32" );
   Encoding^ u32BE = Encoding::GetEncoding( "utf-32BE" );
   
   // Use a string containing the following characters:
   //    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)
   String^ myStr = "za\u0306\u01FD\u03B2";
   
   // Encode the string using the big-endian byte order.
   array<Byte>^barrBE = gcnew array<Byte>(u32BE->GetByteCount( myStr ));
   u32BE->GetBytes( myStr, 0, myStr->Length, barrBE, 0 );
   
   // Encode the string using the little-endian byte order.
   array<Byte>^barrLE = gcnew array<Byte>(u32LE->GetByteCount( myStr ));
   u32LE->GetBytes( myStr, 0, myStr->Length, barrLE, 0 );
   
   // Get the char counts, decode eight bytes starting at index 0,
   // and print out the counts and the resulting bytes.
   Console::Write( "BE array with BE encoding : " );
   PrintCountsAndChars( barrBE, 0, 8, u32BE );
   Console::Write( "LE array with LE encoding : " );
   PrintCountsAndChars( barrLE, 0, 8, u32LE );
}

void PrintCountsAndChars( array<Byte>^bytes, int index, int count, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-25} :", enc );
   
   // Display the exact character count.
   int iCC = enc->GetCharCount( bytes, index, count );
   Console::Write( " {0,-3}", iCC );
   
   // Display the maximum character count.
   int iMCC = enc->GetMaxCharCount( count );
   Console::Write( " {0,-3} :", iMCC );
   
   // Decode the bytes and display the characters.
   array<Char>^chars = enc->GetChars( bytes, index, count );
   
   // The following is an alternative way to decode the bytes:
   // Char[] chars = new Char[iCC];
   // enc->GetChars( bytes, index, count, chars, 0 );
   Console::WriteLine( chars );
}

/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

BE array with BE encoding : System.Text.UTF32Encoding : 2   6   :za
LE array with LE encoding : System.Text.UTF32Encoding : 2   6   :za

*/
using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

      // Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
      Encoding u32LE = Encoding.GetEncoding( "utf-32" );
      Encoding u32BE = Encoding.GetEncoding( "utf-32BE" );

      // Use a string containing the following characters:
      //    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)
      String myStr = "za\u0306\u01FD\u03B2";

      // Encode the string using the big-endian byte order.
      byte[] barrBE = new byte[u32BE.GetByteCount( myStr )];
      u32BE.GetBytes( myStr, 0, myStr.Length, barrBE, 0 );

      // Encode the string using the little-endian byte order.
      byte[] barrLE = new byte[u32LE.GetByteCount( myStr )];
      u32LE.GetBytes( myStr, 0, myStr.Length, barrLE, 0 );

      // Get the char counts, decode eight bytes starting at index 0,
      // and print out the counts and the resulting bytes.
      Console.Write( "BE array with BE encoding : " );
      PrintCountsAndChars( barrBE, 0, 8, u32BE );
      Console.Write( "LE array with LE encoding : " );
      PrintCountsAndChars( barrLE, 0, 8, u32LE );
   }

   public static void PrintCountsAndChars( byte[] bytes, int index, int count, Encoding enc )  {

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

      // Display the exact character count.
      int iCC  = enc.GetCharCount( bytes, index, count );
      Console.Write( " {0,-3}", iCC );

      // Display the maximum character count.
      int iMCC = enc.GetMaxCharCount( count );
      Console.Write( " {0,-3} :", iMCC );

      // Decode the bytes and display the characters.
      char[] chars = enc.GetChars( bytes, index, count );

      // The following is an alternative way to decode the bytes:
      // char[] chars = new char[iCC];
      // enc.GetChars( bytes, index, count, chars, 0 );

      Console.WriteLine( chars );
   }
}


/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

BE array with BE encoding : System.Text.UTF32Encoding : 2   6   :za
LE array with LE encoding : System.Text.UTF32Encoding : 2   6   :za

*/
Imports System.Text

Public Class SamplesEncoding   

   Public Shared Sub Main()

      ' Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
      Dim u32LE As Encoding = Encoding.GetEncoding("utf-32")
      Dim u32BE As Encoding = Encoding.GetEncoding("utf-32BE")

      ' Use a string containing the following characters:
      '    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)
      Dim myStr As String = "za" & ChrW(&H0306) & ChrW(&H01FD) & ChrW(&H03B2)

      ' Encode the string using the big-endian byte order.
      ' NOTE: In VB.NET, arrays contain one extra element by default.
      '       The following line creates barrBE with the exact number of elements required.
      Dim barrBE(u32BE.GetByteCount(myStr) - 1) As Byte
      u32BE.GetBytes(myStr, 0, myStr.Length, barrBE, 0)

      ' Encode the string using the little-endian byte order.
      ' NOTE: In VB.NET, arrays contain one extra element by default.
      '       The following line creates barrLE with the exact number of elements required.
      Dim barrLE(u32LE.GetByteCount(myStr) - 1) As Byte
      u32LE.GetBytes(myStr, 0, myStr.Length, barrLE, 0)

      ' Get the char counts, decode eight bytes starting at index 0,
      ' and print out the counts and the resulting bytes.
      Console.Write("BE array with BE encoding : ")
      PrintCountsAndChars(barrBE, 0, 8, u32BE)
      Console.Write("LE array with LE encoding : ")
      PrintCountsAndChars(barrLE, 0, 8, u32LE)

   End Sub


   Public Shared Sub PrintCountsAndChars(bytes() As Byte, index As Integer, count As Integer, enc As Encoding)

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

      ' Display the exact character count.
      Dim iCC As Integer = enc.GetCharCount(bytes, index, count)
      Console.Write(" {0,-3}", iCC)

      ' Display the maximum character count.
      Dim iMCC As Integer = enc.GetMaxCharCount(count)
      Console.Write(" {0,-3} :", iMCC)

      ' Decode the bytes.
      Dim chars As Char() = enc.GetChars(bytes, index, count)

      ' The following is an alternative way to decode the bytes:
      ' 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 chars(iCC - 1) As Char
      ' enc.GetChars( bytes, index, count, chars, 0 )

      ' Display the characters.
      Console.WriteLine(chars)

   End Sub

End Class


'This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.
'
'BE array with BE encoding : System.Text.UTF32Encoding : 2   6   :za
'LE array with LE encoding : System.Text.UTF32Encoding : 2   6   :za

注釈

Encoding.GetChars入力バイトシーケンスから文字を取得します。 Encoding.GetCharsはとは Decoder.GetChars 異なり Encoding 、は不連続変換を想定し Decoder ていますが、は1つの入力ストリームに対して複数のパスを使用するように設計されています。

変換するデータが、連続したブロック (ストリームから読み取られたデータなど) でのみ使用可能な場合、またはデータの量が大きく、小さいブロックに分割する必要がある場合は、 DecoderEncoderGetDecoder 派生クラスのメソッドまたはメソッドによって提供されるまたはを使用する必要があり GetEncoder ます。

注意

このメソッドは、バイト配列などの任意のバイナリデータではなく、Unicode 文字を操作することを目的としています。 任意のバイナリデータをテキストにエンコードする必要がある場合は、uuencode などのプロトコルを使用する必要があります。これは、などのメソッドによって実装され Convert.ToBase64CharArray ます。

メソッドは、 GetCharCount バイトシーケンスをデコードする文字数を決定し、メソッドは GetChars 実際のデコードを実行します。 メソッドは、 Encoding.GetCharsDecoder.GetChars 1 つの入力ストリームに対して複数のパスを処理するメソッドとは対照的に、離散変換を必要とします。

とのいくつかのバージョン GetCharCountGetChars がサポートされています。 これらのメソッドを使用するためのプログラミング上の考慮事項を次に示します。

  • アプリでは、複数の呼び出しを使用して、コードページから複数の入力バイトをデコードし、バイトを処理することが必要になる場合があります。 この場合は、バッチ処理時にバイトシーケンスが中断される可能性があるため、呼び出し間で状態を維持する必要があります。 (たとえば、ISO-2022 シフト シーケンスの一部は、1 つの GetChars 呼び出しを終了し、次 GetChars の呼び出しの開始時に続行できます。 Encoding.GetChars これらの不完全なシーケンスのフォールバックを呼び出しますが Decoder 、次の呼び出しのシーケンスを記憶します)。

  • アプリが文字列出力を処理する場合は、メソッドを使用することをお勧め GetString します。 このメソッドは文字列の長さを確認してバッファーを割り当てる必要があるため、少し遅くなりますが、結果の String 型が優先されます。

  • のバイトバージョンでは GetChars(Byte*, Int32, Char*, Int32) 、特に大きなバッファーを複数回呼び出す場合に、いくつかの高速な手法が許可されます。 ただし、ポインターが必要であるため、このメソッドのバージョンは安全でない場合があることに注意してください。

  • アプリで大量のデータを変換する必要がある場合は、出力バッファーを再利用する必要があります。 この場合、 GetChars(Byte[], Int32, Int32, Char[], Int32) 出力文字バッファーをサポートするバージョンが最適な選択肢です。

  • ではなく、メソッドを使用することを検討してください Decoder.ConvertGetCharCount 。 変換メソッドは、可能な限り多くのデータを変換し、出力バッファーが小さすぎる場合は例外をスローします。 ストリームを連続してデコードする場合は、この方法が最適な選択肢です。

こちらもご覧ください

適用対象

GetChars(ReadOnlySpan<Byte>, Span<Char>)

派生クラスでオーバーライドされた場合、指定した読み取り専用バイト スパンに格納されているすべてのバイトを、文字スパンにデコードします。

public:
 virtual int GetChars(ReadOnlySpan<System::Byte> bytes, Span<char> chars);
public virtual int GetChars (ReadOnlySpan<byte> bytes, Span<char> chars);
abstract member GetChars : ReadOnlySpan<byte> * Span<char> -> int
override this.GetChars : ReadOnlySpan<byte> * Span<char> -> int
Public Overridable Function GetChars (bytes As ReadOnlySpan(Of Byte), chars As Span(Of Char)) As Integer

パラメーター

bytes
ReadOnlySpan<Byte>

デコード対象のバイト シーケンスが格納された読み取り専用スパン。

chars
Span<Char>

デコードされたバイトを受け取る文字スパン。

戻り値

chars パラメーターによって示されるスパンに書き込む実際の文字数。

注釈

Encoding.GetChars入力バイト範囲から文字を取得します。 Encoding.GetCharsはとは Decoder.GetChars 異なり Encoding 、は不連続変換を想定し Decoder ていますが、は1つの入力ストリームに対して複数のパスを使用するように設計されています。

変換するデータが、連続したブロック (ストリームから読み取られたデータなど) でのみ使用可能な場合、またはデータの量が大きく、小さいブロックに分割する必要がある場合は、 DecoderEncoderGetDecoder 派生クラスのメソッドまたはメソッドによって提供されるまたはを使用する必要があり GetEncoder ます。

メソッドは、 GetCharCount バイトシーケンスをデコードする文字数を決定し、メソッドは GetChars 実際のデコードを実行します。 メソッドは、 Encoding.GetCharsDecoder.GetChars 1 つの入力ストリームに対して複数のパスを処理するメソッドとは対照的に、離散変換を必要とします。

とのいくつかのバージョン GetCharCountGetChars がサポートされています。 これらのメソッドを使用するためのプログラミング上の考慮事項を次に示します。

  • アプリでは、複数の呼び出しを使用して、コードページから複数の入力バイトをデコードし、バイトを処理することが必要になる場合があります。 この場合は、バッチ処理時にバイトシーケンスが中断される可能性があるため、呼び出し間で状態を維持する必要があります。 (たとえば、ISO-2022 シフト シーケンスの一部は、1 つの GetChars 呼び出しを終了し、次 GetChars の呼び出しの開始時に続行できます。 Encoding.GetChars これらの不完全なシーケンスのフォールバックを呼び出しますが Decoder 、次の呼び出しのシーケンスを記憶します)。

  • アプリが文字列出力を処理する場合は、メソッドを使用することをお勧め GetString します。 このメソッドは文字列の長さを確認してバッファーを割り当てる必要があるため、少し遅くなりますが、結果の String 型が優先されます。

  • のバイトバージョンでは GetChars(Byte*, Int32, Char*, Int32) 、特に大きなバッファーを複数回呼び出す場合に、いくつかの高速な手法が許可されます。 ただし、ポインターが必要であるため、このメソッドのバージョンは安全でない場合があることに注意してください。

  • アプリで大量のデータを変換する必要がある場合は、出力バッファーを再利用する必要があります。 この場合、 GetChars(Byte[], Int32, Int32, Char[], Int32) 出力文字バッファーをサポートするバージョンが最適な選択肢です。

  • ではなく、メソッドを使用することを検討してください Decoder.ConvertGetCharCount 。 変換メソッドは、可能な限り多くのデータを変換し、出力バッファーが小さすぎる場合は例外をスローします。 ストリームを連続してデコードする場合は、この方法が最適な選択肢です。

適用対象

GetChars(Byte[])

派生クラスでオーバーライドされた場合、指定したバイト配列に格納されているすべてのバイトを文字のセットにデコードします。

public:
 virtual cli::array <char> ^ GetChars(cli::array <System::Byte> ^ bytes);
public virtual char[] GetChars (byte[] bytes);
abstract member GetChars : byte[] -> char[]
override this.GetChars : byte[] -> char[]
Public Overridable Function GetChars (bytes As Byte()) As Char()

パラメーター

bytes
Byte[]

デコード対象のバイト シーケンスが格納されたバイト配列。

戻り値

Char[]

指定したバイト シーケンスのデコード結果が格納された文字配列。

例外

bytesnull です。

フォールバックが発生しました (詳細については「.NET での文字エンコード」を参照)

および

DecoderFallbackDecoderExceptionFallback に設定されます。

次の例では、文字列をバイト配列にエンコードし、バイトを文字配列にデコードします。

using namespace System;
using namespace System::Text;
void PrintCountsAndChars( array<Byte>^bytes, Encoding^ enc );
int main()
{
   
   // Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
   Encoding^ u32LE = Encoding::GetEncoding( "utf-32" );
   Encoding^ u32BE = Encoding::GetEncoding( "utf-32BE" );
   
   // Use a string containing the following characters:
   //    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)
   String^ myStr = "za\u0306\u01FD\u03B2";
   
   // Encode the string using the big-endian byte order.
   array<Byte>^barrBE = gcnew array<Byte>(u32BE->GetByteCount( myStr ));
   u32BE->GetBytes( myStr, 0, myStr->Length, barrBE, 0 );
   
   // Encode the string using the little-endian byte order.
   array<Byte>^barrLE = gcnew array<Byte>(u32LE->GetByteCount( myStr ));
   u32LE->GetBytes( myStr, 0, myStr->Length, barrLE, 0 );
   
   // Get the char counts, and decode the byte arrays.
   Console::Write( "BE array with BE encoding : " );
   PrintCountsAndChars( barrBE, u32BE );
   Console::Write( "LE array with LE encoding : " );
   PrintCountsAndChars( barrLE, u32LE );
}

void PrintCountsAndChars( array<Byte>^bytes, Encoding^ enc )
{
   
   // Display the name of the encoding used.
   Console::Write( "{0,-25} :", enc );
   
   // Display the exact character count.
   int iCC = enc->GetCharCount( bytes );
   Console::Write( " {0,-3}", iCC );
   
   // Display the maximum character count.
   int iMCC = enc->GetMaxCharCount( bytes->Length );
   Console::Write( " {0,-3} :", iMCC );
   
   // Decode the bytes and display the characters.
   array<Char>^chars = enc->GetChars( bytes );
   Console::WriteLine( chars );
}

/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

BE array with BE encoding : System.Text.UTF32Encoding : 5   12  :zăǽβ
LE array with LE encoding : System.Text.UTF32Encoding : 5   12  :zăǽβ

*/
using System;
using System.Text;

public class SamplesEncoding  {

   public static void Main()  {

      // Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
      Encoding u32LE = Encoding.GetEncoding( "utf-32" );
      Encoding u32BE = Encoding.GetEncoding( "utf-32BE" );

      // Use a string containing the following characters:
      //    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)
      String myStr = "za\u0306\u01FD\u03B2";

      // Encode the string using the big-endian byte order.
      byte[] barrBE = new byte[u32BE.GetByteCount( myStr )];
      u32BE.GetBytes( myStr, 0, myStr.Length, barrBE, 0 );

      // Encode the string using the little-endian byte order.
      byte[] barrLE = new byte[u32LE.GetByteCount( myStr )];
      u32LE.GetBytes( myStr, 0, myStr.Length, barrLE, 0 );

      // Get the char counts, and decode the byte arrays.
      Console.Write( "BE array with BE encoding : " );
      PrintCountsAndChars( barrBE, u32BE );
      Console.Write( "LE array with LE encoding : " );
      PrintCountsAndChars( barrLE, u32LE );
   }

   public static void PrintCountsAndChars( byte[] bytes, Encoding enc )  {

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

      // Display the exact character count.
      int iCC  = enc.GetCharCount( bytes );
      Console.Write( " {0,-3}", iCC );

      // Display the maximum character count.
      int iMCC = enc.GetMaxCharCount( bytes.Length );
      Console.Write( " {0,-3} :", iMCC );

      // Decode the bytes and display the characters.
      char[] chars = enc.GetChars( bytes );
      Console.WriteLine( chars );
   }
}


/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

BE array with BE encoding : System.Text.UTF32Encoding : 5   12  :zăǽβ
LE array with LE encoding : System.Text.UTF32Encoding : 5   12  :zăǽβ

*/
Imports System.Text

Public Class SamplesEncoding   

   Public Shared Sub Main()

      ' Create two instances of UTF32Encoding: one with little-endian byte order and one with big-endian byte order.
      Dim u32LE As Encoding = Encoding.GetEncoding("utf-32")
      Dim u32BE As Encoding = Encoding.GetEncoding("utf-32BE")

      ' Use a string containing the following characters:
      '    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)
      Dim myStr As String = "za" & ChrW(&H0306) & ChrW(&H01FD) & ChrW(&H03B2) 

      ' Encode the string using the big-endian byte order.
      ' 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 barrBE(u32BE.GetByteCount(myStr) - 1) As Byte
      u32BE.GetBytes(myStr, 0, myStr.Length, barrBE, 0)

      ' Encode the string using the little-endian byte order.
      ' 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 barrLE(u32LE.GetByteCount(myStr) - 1) As Byte
      u32LE.GetBytes(myStr, 0, myStr.Length, barrLE, 0)

      ' Get the char counts, and decode the byte arrays.
      Console.Write("BE array with BE encoding : ")
      PrintCountsAndChars(barrBE, u32BE)
      Console.Write("LE array with LE encoding : ")
      PrintCountsAndChars(barrLE, u32LE)

   End Sub


   Public Shared Sub PrintCountsAndChars(bytes() As Byte, enc As Encoding)

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

      ' Display the exact character count.
      Dim iCC As Integer = enc.GetCharCount(bytes)
      Console.Write(" {0,-3}", iCC)

      ' Display the maximum character count.
      Dim iMCC As Integer = enc.GetMaxCharCount(bytes.Length)
      Console.Write(" {0,-3} :", iMCC)

      ' Decode the bytes and display the characters.
      Dim chars As Char() = enc.GetChars(bytes)
      Console.WriteLine(chars)

   End Sub

End Class


'This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.
'
'BE array with BE encoding : System.Text.UTF32Encoding : 5   12  :zăǽβ
'LE array with LE encoding : System.Text.UTF32Encoding : 5   12  :zăǽβ

注釈

Encoding.GetChars入力バイトシーケンスから文字を取得します。 Encoding.GetCharsはとは Decoder.GetChars 異なり Encoding 、は不連続変換を想定し Decoder ていますが、は1つの入力ストリームに対して複数のパスを使用するように設計されています。

変換するデータが、連続したブロック (ストリームから読み取られたデータなど) でのみ使用可能な場合、またはデータの量が大きく、小さいブロックに分割する必要がある場合は、 DecoderEncoderGetDecoder 派生クラスのメソッドまたはメソッドによって提供されるまたはを使用する必要があり GetEncoder ます。

注意

このメソッドは、バイト配列などの任意のバイナリデータではなく、Unicode 文字を操作することを目的としています。 任意のバイナリデータをテキストにエンコードする必要がある場合は、uuencode などのプロトコルを使用する必要があります。これは、などのメソッドによって実装され Convert.ToBase64CharArray ます。

メソッドは、 GetCharCount バイトシーケンスをデコードする文字数を決定し、メソッドは GetChars 実際のデコードを実行します。 メソッドは、 Encoding.GetCharsDecoder.GetChars 1 つの入力ストリームに対して複数のパスを処理するメソッドとは対照的に、離散変換を必要とします。

とのいくつかのバージョン GetCharCountGetChars がサポートされています。 これらのメソッドを使用するためのプログラミング上の考慮事項を次に示します。

  • アプリでは、複数の呼び出しを使用して、コードページから複数の入力バイトをデコードし、バイトを処理することが必要になる場合があります。 この場合は、バッチ処理時にバイトシーケンスが中断される可能性があるため、呼び出し間で状態を維持する必要があります。 (たとえば、ISO-2022 シフト シーケンスの一部は、1 つの GetChars 呼び出しを終了し、次 GetChars の呼び出しの開始時に続行できます。 Encoding.GetChars これらの不完全なシーケンスのフォールバックを呼び出しますが Decoder 、次の呼び出しのシーケンスを記憶します)。

  • アプリが文字列出力を処理する場合は、メソッドを使用することをお勧め GetString します。 このメソッドは文字列の長さを確認してバッファーを割り当てる必要があるため、少し遅くなりますが、結果の String 型が優先されます。

  • のバイトバージョンでは GetChars(Byte*, Int32, Char*, Int32) 、特に大きなバッファーを複数回呼び出す場合に、いくつかの高速な手法が許可されます。 ただし、ポインターが必要であるため、このメソッドのバージョンは安全でない場合があることに注意してください。

  • アプリで大量のデータを変換する必要がある場合は、出力バッファーを再利用する必要があります。 この場合、 GetChars(Byte[], Int32, Int32, Char[], Int32) 出力文字バッファーをサポートするバージョンが最適な選択肢です。

  • ではなく、メソッドを使用することを検討してください Decoder.ConvertGetCharCount 。 変換メソッドは、可能な限り多くのデータを変換し、出力バッファーが小さすぎる場合は例外をスローします。 ストリームを連続してデコードする場合は、この方法が最適な選択肢です。

こちらもご覧ください

適用対象