Decoder.GetChars Metodo

Definizione

Spazio dei nomi:

System.Text

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Assembly:

System.Text.Encoding.dll

Quando ne viene eseguito l'override in una classe derivata, decodifica una sequenza di byte in un set di caratteri.

Overload

GetChars(ReadOnlySpan<Byte>, Span<Char>, Boolean)	Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte nell'intervallo e tutti i byte presenti nel buffer interno in un set di caratteri archiviati a partire dal puntatore di caratteri specificato. Un parametro indica se annullare lo stato interno del decodificatore dopo la conversione.
GetChars(Byte*, Int32, Char*, Int32, Boolean)	Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte a partire dal puntatore ai byte specificato e qualsiasi byte presente nel buffer interno in un set di caratteri archiviati a partire dal puntatore ai caratteri specificato. Un parametro indica se annullare lo stato interno del decodificatore dopo la conversione.
GetChars(Byte[], Int32, Int32, Char[], Int32)	Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte della matrice di byte specificata e qualsiasi byte presente nel buffer interno nella matrice di caratteri specificata.
GetChars(Byte[], Int32, Int32, Char[], Int32, Boolean)	Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte della matrice di byte specificata e qualsiasi byte presente nel buffer interno nella matrice di caratteri specificata. Un parametro indica se annullare lo stato interno del decodificatore dopo la conversione.

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

Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte nell'intervallo e tutti i byte presenti nel buffer interno in un set di caratteri archiviati a partire dal puntatore di caratteri specificato. Un parametro indica se annullare lo stato interno del decodificatore dopo la conversione.

public:
 virtual int GetChars(ReadOnlySpan<System::Byte> bytes, Span<char> chars, bool flush);

public virtual int GetChars (ReadOnlySpan<byte> bytes, Span<char> chars, bool flush);

abstract member GetChars : ReadOnlySpan<byte> * Span<char> * bool -> int
override this.GetChars : ReadOnlySpan<byte> * Span<char> * bool -> int

Public Overridable Function GetChars (bytes As ReadOnlySpan(Of Byte), chars As Span(Of Char), flush As Boolean) As Integer

Parametri

bytes

ReadOnlySpan<Byte>

Intervallo di byte da decodificare.

chars

Span<Char>

Intervallo in cui scrivere il set di caratteri risultante.

flush

Boolean

true per cancellare lo stato interno del decodificatore dopo la conversione. In caso contrario, false.

Restituisce

Int32

Numero effettivo di caratteri scritti nell'intervallo indicato dal parametro chars.

Commenti

Tenere presente che Decoder l'oggetto salva lo stato tra le chiamate a GetChars . Quando l'applicazione viene eseguita con un flusso di dati, deve impostare il parametro su per assicurarsi che le informazioni sullo flush true stato siano scaricate. Con questa impostazione, il decodificatore ignora i byte non validi alla fine del blocco di dati e cancella il buffer interno.

Per calcolare le dimensioni esatte dell'intervallo GetChars necessarie per archiviare i caratteri risultanti, l'applicazione deve usare GetCharCount .

Se viene chiamato con impostato su , il decodificatore archivia i byte finali alla fine del blocco di dati in un buffer interno e li usa nella GetChars flush successiva operazione di false decodifica. L'applicazione deve chiamare su un blocco di dati immediatamente prima di chiamare sullo stesso blocco, in modo che tutti i byte finali del blocco precedente siano GetCharCount GetChars inclusi nel calcolo.

Se l'applicazione deve convertire molti segmenti di un flusso di input, è consigliabile usare il Convert metodo . GetChars genererà un'eccezione se l'intervallo di output non è sufficientemente grande, ma riempirà la maggior quantità possibile di spazio e restituirà i byte letti e i caratteri scritti, purché la matrice di output consenta almeno Convert due caratteri. Vedere anche Encoding.GetChars l'argomento per altri commenti.

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

Importante

Questa API non è conforme a CLS.

Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte a partire dal puntatore ai byte specificato e qualsiasi byte presente nel buffer interno in un set di caratteri archiviati a partire dal puntatore ai caratteri specificato. Un parametro indica se annullare lo stato interno del decodificatore dopo la conversione.

public:
 virtual int GetChars(System::Byte* bytes, int byteCount, char* chars, int charCount, bool flush);

[System.CLSCompliant(false)]
public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount, bool flush);

public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount, bool flush);

[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount, bool flush);

[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(false)]
[System.Security.SecurityCritical]
public virtual int GetChars (byte* bytes, int byteCount, char* chars, int charCount, bool flush);

[<System.CLSCompliant(false)>]
abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int

abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int

[<System.CLSCompliant(false)>]
[<System.Runtime.InteropServices.ComVisible(false)>]
abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int

[<System.CLSCompliant(false)>]
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Security.SecurityCritical>]
abstract member GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int
override this.GetChars : nativeptr<byte> * int * nativeptr<char> * int * bool -> int

Parametri

bytes

Byte*

Puntatore al primo byte da decodificare.

byteCount

Int32

Numero di byte da decodificare.

chars

Char*

Puntatore alla posizione in cui iniziare a scrivere il set di caratteri risultante.

charCount

Int32

Numero massimo di caratteri da scrivere.

flush

Boolean

true per cancellare lo stato interno del decodificatore dopo la conversione. In caso contrario, false.

Restituisce

Int32

Numero effettivo di caratteri scritti nella posizione indicata dal parametro chars.

Attributi

CLSCompliantAttribute ComVisibleAttribute SecurityCriticalAttribute

Eccezioni

ArgumentNullException

bytes è null (Nothing).

-oppure-

chars è null (Nothing).

ArgumentOutOfRangeException

byteCount o charCount è minore di zero.

ArgumentException

charCount è minore del numero di caratteri risultante.

DecoderFallbackException

Si è verificato un fallback (per altre informazioni, vedere Codifica dei caratteri in .NET)

-e-

Fallback è impostato su DecoderExceptionFallback.

Commenti

Tenere presente che Decoder l'oggetto salva lo stato tra le chiamate a GetChars . Quando l'applicazione viene eseguita con un flusso di dati, deve impostare il parametro su per assicurarsi che le informazioni sullo flush true stato siano scaricate. Con questa impostazione, il decodificatore ignora i byte non validi alla fine del blocco di dati e cancella il buffer interno.

Per calcolare le dimensioni esatte del buffer GetChars necessarie per archiviare i caratteri risultanti, l'applicazione deve usare GetCharCount .

Se viene chiamato con impostato su , il decodificatore archivia i byte finali alla fine del blocco di dati in un buffer interno e li usa nella GetChars flush successiva operazione di false decodifica. L'applicazione deve chiamare su un blocco di dati immediatamente prima di chiamare sullo stesso blocco, in modo che tutti i byte finali del blocco precedente siano GetCharCount GetChars inclusi nel calcolo.

Se l'applicazione deve convertire molti segmenti di un flusso di input, è consigliabile usare il Convert metodo . GetChars genererà un'eccezione se il buffer di output non è sufficientemente grande, ma riempirà la maggior quantità possibile di spazio e restituirà i byte letti e i caratteri scritti, a condizione che la matrice di output consenta almeno Convert due caratteri. Vedere anche Encoding.GetChars l'argomento per altri commenti.

Vedi anche

• GetCharCount(Byte*, Int32, Boolean)
• Reset()

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

Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte della matrice di byte specificata e qualsiasi byte presente nel buffer interno nella matrice di caratteri specificata.

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

Parametri

bytes

Byte[]

Matrice di byte contenente la sequenza di byte da decodificare.

byteIndex

Int32

Indice del primo byte da decodificare.

byteCount

Int32

Numero di byte da decodificare.

chars

Char[]

Matrice di caratteri che deve contenere il set di caratteri risultante.

charIndex

Int32

Indice in corrispondenza del quale iniziare a scrivere il set di caratteri risultante.

Restituisce

Int32

Numero effettivo di caratteri scritti in chars.

Eccezioni

ArgumentNullException

bytes è null (Nothing).

-oppure-

chars è null (Nothing).

ArgumentOutOfRangeException

byteIndex o byteCount o charIndex è minore di zero.

-oppure-

byteindex e byteCount non identificano un intervallo valido in bytes.

-oppure-

charIndex non è un indice valido in chars.

ArgumentException

chars non dispone di sufficiente capacità da charIndex alla fine della matrice per contenere i caratteri risultanti.

DecoderFallbackException

Si è verificato un fallback (per altre informazioni, vedere Codifica dei caratteri in .NET)

-e-

Fallback è impostato su DecoderExceptionFallback.

Esempio

Nell'esempio seguente viene illustrato come decodificare un intervallo di elementi da una matrice di byte e archiviarli in una matrice di caratteri Unicode. Il GetCharCount metodo viene usato per calcolare il numero di caratteri necessari per archiviare gli elementi decodificati nella matrice bytes . Il GetChars metodo decodifica gli elementi specificati nella matrice di byte e li archivia nella nuova matrice di caratteri.

using namespace System;
using namespace System::Text;
using namespace System::Collections;
int main()
{
   array<Char>^chars;
   array<Byte>^bytes = {85,0,110,0,105,0,99,0,111,0,100,0,101,0};
   Decoder^ uniDecoder = Encoding::Unicode->GetDecoder();
   int charCount = uniDecoder->GetCharCount( bytes, 0, bytes->Length );
   chars = gcnew array<Char>(charCount);
   int charsDecodedCount = uniDecoder->GetChars( bytes, 0, bytes->Length, chars, 0 );
   Console::WriteLine( "{0} characters used to decode bytes.", charsDecodedCount );
   Console::Write( "Decoded chars: " );
   IEnumerator^ myEnum = chars->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Char c = safe_cast<Char>(myEnum->Current);
      Console::Write( "[{0}]", c.ToString() );
   }

   Console::WriteLine();
}

/* This code example produces the following output.

7 characters used to decode bytes.
Decoded chars: [U][n][i][c][o][d][e]

*/

using System;
using System.Text;

class UnicodeEncodingExample {
    public static void Main() {
        Char[] chars;
        Byte[] bytes = new Byte[] {
            85, 0, 110, 0, 105, 0, 99, 0, 111, 0, 100, 0, 101, 0
        };

        Decoder uniDecoder = Encoding.Unicode.GetDecoder();

        int charCount = uniDecoder.GetCharCount(bytes, 0, bytes.Length);
        chars = new Char[charCount];
        int charsDecodedCount = uniDecoder.GetChars(bytes, 0, bytes.Length, chars, 0);

        Console.WriteLine(
            "{0} characters used to decode bytes.", charsDecodedCount
        );

        Console.Write("Decoded chars: ");
        foreach (Char c in chars) {
            Console.Write("[{0}]", c);
        }
        Console.WriteLine();
    }
}

/* This code example produces the following output.

7 characters used to decode bytes.
Decoded chars: [U][n][i][c][o][d][e]

*/

Imports System.Text

Class UnicodeEncodingExample
    
    Public Shared Sub Main()
        Dim chars() As Char
        Dim bytes() As Byte = { _
            85, 0, 110, 0, 105, 0, 99, 0, 111, 0, 100, 0, 101, 0 _
        }
        
        Dim uniDecoder As Decoder = Encoding.Unicode.GetDecoder()
        
        Dim charCount As Integer = uniDecoder.GetCharCount(bytes, 0, bytes.Length)
        chars = New Char(charCount - 1) {}
        Dim charsDecodedCount As Integer = _
            uniDecoder.GetChars(bytes, 0, bytes.Length, chars, 0)
        
        Console.WriteLine( _
            "{0} characters used to decode bytes.", _
            charsDecodedCount _
        )
        
        Console.Write("Decoded chars: ")
        Dim c As Char
        For Each c In  chars
            Console.Write("[{0}]", c)
        Next c
        Console.WriteLine()
    End Sub
End Class

'This code example produces the following output.
'
'7 characters used to decode bytes.
'Decoded chars: [U][n][i][c][o][d][e]
'

Commenti

Tenere presente che Decoder l'oggetto salva lo stato tra le chiamate a GetChars . Quando l'applicazione viene eseguita con un flusso di dati, deve impostare il parametro su per assicurarsi che le informazioni sullo flush true stato siano scaricate. Con questa impostazione, il decodificatore ignora i byte non validi alla fine del blocco di dati e cancella il buffer interno.

Per calcolare le dimensioni esatte della matrice GetChars necessarie per archiviare i caratteri risultanti, l'applicazione deve usare GetCharCount .

Se viene chiamato con impostato su , il decodificatore archivia i byte finali alla fine del blocco di dati in un buffer interno e li usa nella GetChars flush successiva operazione di false decodifica. L'applicazione deve chiamare su un blocco di dati immediatamente prima di chiamare sullo stesso blocco, in modo che tutti i byte finali del blocco precedente siano GetCharCount GetChars inclusi nel calcolo.

Se l'applicazione deve convertire molti segmenti di un flusso di input, è consigliabile usare il Convert metodo . GetChars genererà un'eccezione se il buffer di output non è sufficientemente grande, ma riempirà la maggior quantità possibile di spazio e restituirà i byte letti e i caratteri scritti, a condizione che la matrice di output consenta almeno Convert due caratteri. Vedere anche Encoding.GetChars l'argomento per altri commenti.

Vedi anche

• GetCharCount(Byte[], Int32, Int32)
• Reset()

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

Quando sottoposto a override in una classe derivata, decodifica una sequenza di byte della matrice di byte specificata e qualsiasi byte presente nel buffer interno nella matrice di caratteri specificata. Un parametro indica se annullare lo stato interno del decodificatore dopo la conversione.

public:
 virtual int GetChars(cli::array <System::Byte> ^ bytes, int byteIndex, int byteCount, cli::array <char> ^ chars, int charIndex, bool flush);

public virtual int GetChars (byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, bool flush);

abstract member GetChars : byte[] * int * int * char[] * int * bool -> int
override this.GetChars : byte[] * int * int * char[] * int * bool -> int

Public Overridable Function GetChars (bytes As Byte(), byteIndex As Integer, byteCount As Integer, chars As Char(), charIndex As Integer, flush As Boolean) As Integer

Parametri

bytes

Byte[]

Matrice di byte contenente la sequenza di byte da decodificare.

byteIndex

Int32

Indice del primo byte da decodificare.

byteCount

Int32

Numero di byte da decodificare.

chars

Char[]

Matrice di caratteri che deve contenere il set di caratteri risultante.

charIndex

Int32

Indice in corrispondenza del quale iniziare a scrivere il set di caratteri risultante.

flush

Boolean

true per cancellare lo stato interno del decodificatore dopo la conversione. In caso contrario, false.

Restituisce

Int32

Numero effettivo di caratteri scritti nel parametro chars.

Eccezioni

ArgumentNullException

bytes è null (Nothing).

-oppure-

chars è null (Nothing).

ArgumentOutOfRangeException

byteIndex o byteCount o charIndex è minore di zero.

-oppure-

byteindex e byteCount non identificano un intervallo valido in bytes.

-oppure-

charIndex non è un indice valido in chars.

ArgumentException

chars non dispone di sufficiente capacità da charIndex alla fine della matrice per contenere i caratteri risultanti.

DecoderFallbackException

Si è verificato un fallback (per altre informazioni, vedere Codifica dei caratteri in .NET)

-e-

Fallback è impostato su DecoderExceptionFallback.

Commenti

Tenere presente che Decoder l'oggetto salva lo stato tra le chiamate a GetChars . Quando l'applicazione viene eseguita con un flusso di dati, deve impostare il parametro su per assicurarsi che le informazioni sullo flush true stato siano scaricate. Con questa impostazione, il decodificatore ignora i byte non validi alla fine del blocco di dati e cancella il buffer interno.

Per calcolare le dimensioni esatte della matrice GetChars necessarie per archiviare i caratteri risultanti, l'applicazione deve usare GetCharCount .

Se viene chiamato con impostato su , il decodificatore archivia i byte finali alla fine del blocco di dati in un buffer interno e li usa nella GetChars flush successiva operazione di false decodifica. L'applicazione deve chiamare su un blocco di dati immediatamente prima di chiamare sullo stesso blocco, in modo che tutti i byte finali del blocco precedente siano GetCharCount GetChars inclusi nel calcolo.

Se l'applicazione deve convertire molti segmenti di un flusso di input, è consigliabile usare il Convert metodo . GetChars genererà un'eccezione se il buffer di output non è sufficientemente grande, ma riempirà la maggior quantità possibile di spazio e restituirà i byte letti e i caratteri scritti, a condizione che la matrice di output consenta almeno Convert due caratteri. Vedere anche Encoding.GetChars l'argomento per altri commenti.

Vedi anche

• GetCharCount(Byte[], Int32, Int32, Boolean)
• Reset()