Encoder.GetBytes Méthode

  • Référence

Définition

Espace de noms:
System.Text
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll
Assembly:
System.Text.Encoding.dll

En cas de substitution dans une classe dérivée, encode un jeu de caractères en une séquence d'octets.

Surcharges

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

En cas de substitution dans une classe dérivée, encode un jeu de caractères dans l’étendue de caractères d’entrée et tous les caractères de la mémoire tampon interne en une séquence d’octets stockés dans l’étendue d’octets en entrée. Un paramètre indique si l'état interne de l'encodeur doit être effacé après la conversion.
GetBytes(Char*, Int32, Byte*, Int32, Boolean)

En cas de substitution dans une classe dérivée, encode un jeu de caractères démarrant au pointeur de caractère spécifié et les caractères de la mémoire tampon interne en une séquence d'octets stockés à partir du pointeur d'octet spécifié. Un paramètre indique si l'état interne de l'encodeur doit être effacé après la conversion.
GetBytes(Char[], Int32, Int32, Byte[], Int32, Boolean)

En cas de substitution dans une classe dérivée, encode un jeu de caractères du tableau de caractères spécifié et les caractères de la mémoire tampon interne dans le tableau d'octets spécifié. Un paramètre indique si l'état interne de l'encodeur doit être effacé après la conversion.

Remarques

N’oubliez pas que l’objet Encoder enregistre l’état entre les appels à GetBytes. Lorsque l’application a terminé avec un flux de données, elle doit définir le flush paramètre true sur dans le dernier appel pour GetBytes s’assurer que les informations d’état sont vidées et que les octets encodés sont correctement terminés. Avec ce paramètre, l’encodeur ignore les octets non valides à la fin du bloc de données, tels que les substitutions sans correspondance ou les séquences de combinaison incomplètes, et efface la mémoire tampon interne.

Pour calculer la taille exacte de la mémoire tampon qui GetBytes nécessite de stocker les caractères résultants, l’application doit utiliser GetByteCount.

Si GetBytes est appelé avec flush défini sur false, l’encodeur stocke les octets de fin à la fin du bloc de données dans une mémoire tampon interne et les utilise dans l’opération d’encodage suivante. L’application doit appeler GetByteCount sur un bloc de données immédiatement avant d’appeler GetBytes sur le même bloc, afin que tous les caractères de fin du bloc précédent soient inclus dans le calcul.

Si votre application doit convertir de nombreux segments d’un flux d’entrée, envisagez d’utiliser la Convert méthode . GetBytes lève une exception si la mémoire tampon de sortie n’est pas assez grande, mais Convert qu’elle occupe autant d’espace que possible et retourne les caractères lus et les octets écrits. Consultez également la Encoding.GetBytes rubrique pour plus de commentaires.

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

Source:
Encoder.cs
Source:
Encoder.cs
Source:
Encoder.cs

En cas de substitution dans une classe dérivée, encode un jeu de caractères dans l’étendue de caractères d’entrée et tous les caractères de la mémoire tampon interne en une séquence d’octets stockés dans l’étendue d’octets en entrée. Un paramètre indique si l'état interne de l'encodeur doit être effacé après la conversion.

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

Paramètres

chars
ReadOnlySpan<Char>

Une étendue de caractères à encoder.

bytes
Span<Byte>

Étendue d’octets dans laquelle écrire la séquence d’octets obtenue.

flush
Boolean

true pour effacer l'état interne de l'encodeur après la conversion ; sinon, false.

Retours

Int32

Nombre réel d'octets écrits à l'emplacement indiqué par le paramètre bytes.

S’applique à

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

Source:
Encoder.cs
Source:
Encoder.cs
Source:
Encoder.cs

Important

Cette API n’est pas conforme CLS.

En cas de substitution dans une classe dérivée, encode un jeu de caractères démarrant au pointeur de caractère spécifié et les caractères de la mémoire tampon interne en une séquence d'octets stockés à partir du pointeur d'octet spécifié. Un paramètre indique si l'état interne de l'encodeur doit être effacé après la conversion.

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

Paramètres

chars
Char*

Pointeur du premier caractère à encoder.

charCount
Int32

Nombre de caractères à encoder.

bytes
Byte*

Pointeur de l'emplacement où commencer l'écriture de la séquence d'octets obtenue.

byteCount
Int32

Nombre maximal d'octets à écrire.

flush
Boolean

true pour effacer l'état interne de l'encodeur après la conversion ; sinon, false.

Retours

Int32

Nombre réel d'octets écrits à l'emplacement indiqué par le paramètre bytes.

Attributs
CLSCompliantAttribute ComVisibleAttribute SecurityCriticalAttribute

Exceptions

ArgumentNullException

chars a la valeur null (Nothing).

- ou -

bytes a la valeur null (Nothing).

ArgumentOutOfRangeException

charCount ou byteCount est inférieur à zéro.

ArgumentException

byteCount est inférieur au nombre d'octets obtenus.

EncoderFallbackException

Un secours s’est produit (pour plus d’informations, consultez Codage de caractères dans .NET)

-et-

Fallback a la valeur EncoderExceptionFallback.

S’applique à

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

Source:
Encoder.cs
Source:
Encoder.cs
Source:
Encoder.cs

En cas de substitution dans une classe dérivée, encode un jeu de caractères du tableau de caractères spécifié et les caractères de la mémoire tampon interne dans le tableau d'octets spécifié. Un paramètre indique si l'état interne de l'encodeur doit être effacé après la conversion.

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

Paramètres

chars
Char[]

Tableau de caractères contenant le jeu de caractères à encoder.

charIndex
Int32

Index du premier caractère à encoder.

charCount
Int32

Nombre de caractères à encoder.

bytes
Byte[]

Tableau d'octets destiné à contenir la séquence d'octets obtenue.

byteIndex
Int32

Index auquel commencer l'écriture de la séquence d'octets obtenue.

flush
Boolean

true pour effacer l'état interne de l'encodeur après la conversion ; sinon, false.

Retours

Int32

Nombre réel d'octets écrits dans bytes.

Exceptions

ArgumentNullException

chars a la valeur null (Nothing).

- ou -

bytes a la valeur null (Nothing).

ArgumentOutOfRangeException

charIndex, charCount ou byteIndex est inférieur à zéro.

- ou -

charIndex et charCount ne désignent pas une plage valide dans chars.

- ou -

byteIndex n'est pas un index valide dans bytes.

ArgumentException

bytes ne possède pas une capacité suffisante entre byteIndex et la fin du tableau pour prendre en charge les octets obtenus.

EncoderFallbackException

Un secours s’est produit (pour plus d’informations, consultez Codage de caractères dans .NET)

-et-

Fallback a la valeur EncoderExceptionFallback.

Exemples

L’exemple suivant montre comment encoder une plage d’éléments à partir d’un tableau de caractères et stocker les octets codés dans une plage d’éléments dans un tableau d’octets. La GetByteCount méthode est utilisée pour déterminer la taille du tableau requis par 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]
'

S’applique à