Encoder.GetBytes Metodo

Definizione

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
Origine:
Encoder.cs
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

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

Si applica a

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

Origine:
Encoder.cs
Origine:
Encoder.cs
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)]
[System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetBytes (char* chars, int charCount, byte* bytes, int byteCount, bool flush);
[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(false)]
[System.Security.SecurityCritical]
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
[<System.CLSCompliant(false)>]
[<System.Runtime.InteropServices.ComVisible(false)>]
abstract member GetBytes : nativeptr<char> * int * nativeptr<byte> * int * bool -> int
override this.GetBytes : nativeptr<char> * int * nativeptr<byte> * int * bool -> int
[<System.CLSCompliant(false)>]
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Security.SecurityCritical>]
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

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

Attributi

Eccezioni

chars è null (Nothing).

-oppure-

bytes è null (Nothing).

charCount o byteCount è minore di zero.

byteCount è minore del numero di byte risultante.

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

-e-

Fallback è impostato su EncoderExceptionFallback.

Si applica a

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

Origine:
Encoder.cs
Origine:
Encoder.cs
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

Numero effettivo di byte scritti in bytes.

Eccezioni

chars è null (Nothing).

-oppure-

bytes è null (Nothing).

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.

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

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]
'

Si applica a