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

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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' Encoder objet enregistre l’état entre les appels à GetBytes . Lorsque l’application est effectuée avec un flux de données, elle doit affecter au flush paramètre la valeur true dans le dernier appel à GetBytes pour s’assurer que les informations d’État sont vidées et que les octets encodés sont terminés correctement. Avec ce paramètre, l’encodeur ignore les octets non valides à la fin du bloc de données, tels que les substituts non appariés 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 GetBytes requise pour stocker les caractères obtenus, l’application doit utiliser GetByteCount .

Si GetBytes est appelé avec flush la valeur 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 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 remplit autant d’espace que possible et retourne les caractères lus et les octets écrits. Consultez également la Encoding.GetBytes rubrique pour obtenir plus de commentaires.

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.

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)

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

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

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)

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 d’un tableau de caractères et comment stocker les octets encodés dans une plage d’éléments d’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 à

Encoder.GetBytes Méthode

Définition

Surcharges

Remarques

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

Paramètres

Retours

S’applique à

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

Paramètres

Retours

Exceptions

S’applique à

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

Paramètres

Retours

Exceptions

Exemples

S’applique à

Ressources supplémentaires

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