Encoder.GetBytes Metodo

Definizione

Spazio dei nomi:

System.Text

Assembly:

System.Runtime.dll

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

Overload

GetBytes(ReadOnlySpan<Char>, Span<Byte>, Boolean)	Quando ne viene eseguito l'override in una classe derivata, codifica un set di caratteri nell'intervallo di caratteri di input e tutti i caratteri nel buffer interno in una sequenza di byte archiviati nell'intervallo di byte di input. Un parametro indica se lo stato interno del codificatore deve essere cancellato dopo la conversione.
GetBytes(Char*, Int32, Byte*, Int32, Boolean)	Quando sottoposto a override in una classe derivata, codifica un set di caratteri partendo dal puntatore ai caratteri specificato e tutti i caratteri presenti nel buffer interno in una sequenza di byte che vengono archiviati a partire dal puntatore ai byte specificato. Un parametro indica se lo stato interno del codificatore deve essere cancellato dopo la conversione.
GetBytes(Char[], Int32, Int32, Byte[], Int32, Boolean)	Quando sottoposto a override in una classe derivata, codifica un set di caratteri partendo dalla matrice di caratteri specificata e tutti i caratteri presenti nel buffer interno nella matrice di byte specificata. Un parametro indica se lo stato interno del codificatore deve essere cancellato dopo la conversione.

Commenti

Tenere presente che l'oggetto Encoder salva lo stato tra le chiamate a GetBytes. Quando l'applicazione viene eseguita con un flusso di dati, deve impostare il flush parametro su true nell'ultima chiamata a GetBytes per assicurarsi che le informazioni sullo stato vengano scaricate e che i byte codificati vengano terminati correttamente. Con questa impostazione, il codificatore ignora i byte non validi alla fine del blocco di dati, ad esempio surrogati non corrispondenti o sequenze di combinazione incompleta e cancella il buffer interno.

Per calcolare la dimensione esatta del buffer che GetBytes richiede di archiviare i caratteri risultanti, l'applicazione deve usare GetByteCount.

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

Se l'applicazione consiste nel convertire molti segmenti di un flusso di input, è consigliabile usare il Convert metodo . GetBytes genererà un'eccezione se il buffer di output non è sufficientemente grande, ma Convert riempirà il maggior numero possibile di spazio e restituirà i caratteri letti e byte scritti. Vedere anche l'argomento Encoding.GetBytes per altri commenti.

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

Origine:

Encoder.cs

Quando ne viene eseguito l'override in una classe derivata, codifica un set di caratteri nell'intervallo di caratteri di input e tutti i caratteri nel buffer interno in una sequenza di byte archiviati nell'intervallo di byte di input. Un parametro indica se lo stato interno del codificatore deve essere cancellato dopo la conversione.

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

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

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

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

Parametri

chars

ReadOnlySpan<Char>

Intervallo di caratteri da codificare.

bytes

Span<Byte>

Intervallo di byte in cui scrivere la sequenza di byte risultante.

flush

Boolean

true per cancellare lo stato interno del codificatore dopo la conversione; in caso contrario, false.

Restituisce

Int32

Numero effettivo di byte scritti nella posizione indicata dal parametro bytes.

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

Origine:

Encoder.cs

Importante

Questa API non è conforme a CLS.

Quando sottoposto a override in una classe derivata, codifica un set di caratteri partendo dal puntatore ai caratteri specificato e tutti i caratteri presenti nel buffer interno in una sequenza di byte che vengono archiviati a partire dal puntatore ai byte specificato. Un parametro indica se lo stato interno del codificatore deve essere cancellato dopo la conversione.

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

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

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

Parametri

chars

Char*

Puntatore al primo carattere da codificare.

charCount

Int32

Numero di caratteri da codificare.

bytes

Byte*

Puntatore alla posizione in cui iniziare a scrivere la sequenza di byte risultante.

byteCount

Int32

Numero massimo di byte da scrivere.

flush

Boolean

true per cancellare lo stato interno del codificatore dopo la conversione; in caso contrario, false.

Restituisce

Int32

Numero effettivo di byte scritti nella posizione indicata dal parametro bytes.

Attributi

CLSCompliantAttribute

Eccezioni

ArgumentNullException

chars è null (Nothing).

-oppure-

bytes è null (Nothing).

ArgumentOutOfRangeException

charCount o byteCount è minore di zero.

ArgumentException

byteCount è minore del numero di byte risultante.

EncoderFallbackException

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

-e-

Fallback è impostato su EncoderExceptionFallback.

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

Origine:

Encoder.cs

Quando sottoposto a override in una classe derivata, codifica un set di caratteri partendo dalla matrice di caratteri specificata e tutti i caratteri presenti nel buffer interno nella matrice di byte specificata. Un parametro indica se lo stato interno del codificatore deve essere cancellato dopo la conversione.

public:
 abstract int GetBytes(cli::array <char> ^ chars, int charIndex, int charCount, cli::array <System::Byte> ^ bytes, int byteIndex, bool flush);

public abstract int GetBytes (char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush);

abstract member GetBytes : char[] * int * int * byte[] * int * bool -> int

Public MustOverride Function GetBytes (chars As Char(), charIndex As Integer, charCount As Integer, bytes As Byte(), byteIndex As Integer, flush As Boolean) As Integer

Parametri

chars

Char[]

Matrice di caratteri contenente il set di caratteri da codificare.

charIndex

Int32

Indice del primo carattere da codificare.

charCount

Int32

Numero di caratteri da codificare.

bytes

Byte[]

Matrice di byte che deve contenere la sequenza di byte risultante.

byteIndex

Int32

Indice in corrispondenza del quale iniziare a scrivere la sequenza di byte risultante.

flush

Boolean

true per cancellare lo stato interno del codificatore dopo la conversione; in caso contrario, false.

Restituisce

Int32

Numero effettivo di byte scritti in bytes.

Eccezioni

ArgumentNullException

chars è null (Nothing).

-oppure-

bytes è null (Nothing).

ArgumentOutOfRangeException

charIndex o charCount o byteIndex è minore di zero.

-oppure-

charIndex e charCount non identificano un intervallo valido in chars.

-oppure-

byteIndex non è un indice valido in bytes.

ArgumentException

bytes non dispone di sufficiente capacità da byteIndex alla fine della matrice per contenere i byte risultanti.

EncoderFallbackException

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

-e-

Fallback è impostato su EncoderExceptionFallback.

Esempio

Nell'esempio seguente viene illustrato come codificare un intervallo di elementi da una matrice di caratteri e archiviare i byte codificati in un intervallo di elementi in una matrice di byte. Il GetByteCount metodo viene usato per determinare le dimensioni della matrice richiesta da GetBytes.

using namespace System;
using namespace System::Text;
using namespace System::Collections;
int main()
{
   array<Byte>^bytes;
   
   // Unicode characters.
   
   // Pi
   // Sigma
   array<Char>^chars = {L'\u03a0',L'\u03a3',L'\u03a6',L'\u03a9'};
   Encoder^ uniEncoder = Encoding::Unicode->GetEncoder();
   int byteCount = uniEncoder->GetByteCount( chars, 0, chars->Length, true );
   bytes = gcnew array<Byte>(byteCount);
   int bytesEncodedCount = uniEncoder->GetBytes( chars, 0, chars->Length, bytes, 0, true );
   Console::WriteLine( "{0} bytes used to encode characters.", bytesEncodedCount );
   Console::Write( "Encoded bytes: " );
   IEnumerator^ myEnum = bytes->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Byte b = safe_cast<Byte>(myEnum->Current);
      Console::Write( "[{0}]", b );
   }

   Console::WriteLine();
}

/* This code example produces the following output.

8 bytes used to encode characters.
Encoded bytes: [160][3][163][3][166][3][169][3]

*/

using System;
using System.Text;

class EncoderExample {
    public static void Main() {
        Byte[] bytes;
        // Unicode characters.
        Char[] chars = new Char[] {
            '\u0023', // #
            '\u0025', // %
            '\u03a0', // Pi
            '\u03a3'  // Sigma
        };
        
        Encoder uniEncoder = Encoding.Unicode.GetEncoder();
        
        int byteCount = uniEncoder.GetByteCount(chars, 0, chars.Length, true);
        bytes = new Byte[byteCount];
        int bytesEncodedCount = uniEncoder.GetBytes(chars, 0, chars.Length, bytes, 0, true);
        
        Console.WriteLine(
            "{0} bytes used to encode characters.", bytesEncodedCount
        );

        Console.Write("Encoded bytes: ");
        foreach (Byte b in bytes) {
            Console.Write("[{0}]", b);
        }
        Console.WriteLine();
    }
}

/* This code example produces the following output.

8 bytes used to encode characters.
Encoded bytes: [35][0][37][0][160][3][163][3]

*/

Imports System.Text
Imports Microsoft.VisualBasic.Strings

Class EncoderExample
    
    Public Shared Sub Main()
        Dim bytes() As Byte
        ' Unicode characters.
        ' ChrW(35)  = #
        ' ChrW(37)  = %
        ' ChrW(928) = Pi
        ' ChrW(931) = Sigma
        Dim chars() As Char = {ChrW(35), ChrW(37), ChrW(928), ChrW(931)}
        
        Dim uniEncoder As Encoder = Encoding.Unicode.GetEncoder()
        
        Dim byteCount As Integer = _
            uniEncoder.GetByteCount(chars, 0, chars.Length, True)
        bytes = New Byte(byteCount - 1) {}
        Dim bytesEncodedCount As Integer = _
            uniEncoder.GetBytes(chars, 0, chars.Length, bytes, 0, True)
        
        Console.WriteLine( _
            "{0} bytes used to encode characters.", _
            bytesEncodedCount _
        )
        
        Console.Write("Encoded bytes: ")
        Dim b As Byte
        For Each b In  bytes
            Console.Write("[{0}]", b)
        Next b
        Console.WriteLine()
    End Sub
End Class

'This code example produces the following output.
'8 bytes used to encode characters.
'Encoded bytes: [35][0][37][0][160][3][163][3]
'