Encoder.GetBytes Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Text

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Assembly:: System.Text.Encoding.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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 Encoder l'oggetto salva lo stato tra le chiamate a GetBytes . Quando l'applicazione viene eseguita con un flusso di dati, deve impostare il parametro su nell'ultima chiamata a per assicurarsi che le informazioni sullo stato siano scaricate e che i byte codificati siano flush true GetBytes 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 combinate incomplete, e cancella il buffer interno.

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

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

Se l'applicazione deve 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 riempirà la quantità di spazio possibile e restituirà i caratteri letti Convert e i byte scritti. Vedere anche Encoding.GetBytes l'argomento per altri commenti.

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.

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.

Si applica a

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

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);

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

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

Int32

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

Attributi: CLSCompliantAttribute ComVisibleAttribute SecurityCriticalAttribute

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.

Si applica a

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.

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

Si applica a

Encoder.GetBytes Metodo

Definizione

Overload

Commenti

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

Parametri

Restituisce

Si applica a

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

Parametri

Restituisce

Eccezioni

Si applica a

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

Parametri

Restituisce

Eccezioni

Esempio

Si applica a

Risorse aggiuntive

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