Encoder.GetBytes Method

Definition

Namespace:

System.Text

Assembly:

System.Runtime.dll

When overridden in a derived class, encodes a set of characters into a sequence of bytes.

Overloads

GetBytes(ReadOnlySpan<Char>, Span<Byte>, Boolean)	When overridden in a derived class, encodes a set of characters in the input characters span and any characters in the internal buffer into a sequence of bytes that are stored in the input byte span. A parameter indicates whether to clear the internal state of the encoder after the conversion.
GetBytes(Char*, Int32, Byte*, Int32, Boolean)	When overridden in a derived class, encodes a set of characters starting at the specified character pointer and any characters in the internal buffer into a sequence of bytes that are stored starting at the specified byte pointer. A parameter indicates whether to clear the internal state of the encoder after the conversion.
GetBytes(Char[], Int32, Int32, Byte[], Int32, Boolean)	When overridden in a derived class, encodes a set of characters from the specified character array and any characters in the internal buffer into the specified byte array. A parameter indicates whether to clear the internal state of the encoder after the conversion.

Remarks

Remember that the Encoder object saves state between calls to GetBytes. When the application is done with a stream of data, it should set the flush parameter to true in the last call to GetBytes to make sure that the state information is flushed and that the encoded bytes are properly terminated. With this setting, the encoder ignores invalid bytes at the end of the data block, such as unmatched surrogates or incomplete combining sequences, and clears the internal buffer.

To calculate the exact buffer size that GetBytes requires to store the resulting characters, the application should use GetByteCount.

If GetBytes is called with flush set to false, the encoder stores trailing bytes at the end of the data block in an internal buffer and uses them in the next encoding operation. The application should call GetByteCount on a block of data immediately before calling GetBytes on the same block, so that any trailing characters from the previous block are included in the calculation.

If your application is to convert many segments of an input stream, consider using the Convert method. GetBytes will throw an exception if the output buffer isn't large enough, but Convert will fill as much space as possible and return the chars read and bytes written. Also see the Encoding.GetBytes topic for more comments.

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

Source:

Encoder.cs

When overridden in a derived class, encodes a set of characters in the input characters span and any characters in the internal buffer into a sequence of bytes that are stored in the input byte span. A parameter indicates whether to clear the internal state of the encoder after the 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

Parameters

chars

ReadOnlySpan<Char>

A character span to encode.

bytes

Span<Byte>

A byte span to write the resulting sequence of bytes to.

flush

Boolean

true to clear the internal state of the encoder after the conversion; otherwise, false.

Returns

Int32

The actual number of bytes written at the location indicated by the bytes parameter.

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

Source:

Encoder.cs

Important

This API is not CLS-compliant.

When overridden in a derived class, encodes a set of characters starting at the specified character pointer and any characters in the internal buffer into a sequence of bytes that are stored starting at the specified byte pointer. A parameter indicates whether to clear the internal state of the encoder after the 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)>]
abstract member GetBytes : nativeptr<char> * int * nativeptr<byte> * int * bool -> int
override this.GetBytes : nativeptr<char> * int * nativeptr<byte> * int * bool -> int

Parameters

chars

Char*

A pointer to the first character to encode.

charCount

Int32

The number of characters to encode.

bytes

Byte*

A pointer to the location at which to start writing the resulting sequence of bytes.

byteCount

Int32

The maximum number of bytes to write.

flush

Boolean

true to clear the internal state of the encoder after the conversion; otherwise, false.

Returns

Int32

The actual number of bytes written at the location indicated by the bytes parameter.

Attributes

CLSCompliantAttribute

Exceptions

ArgumentNullException

chars is null (Nothing).

-or-

bytes is null (Nothing).

ArgumentOutOfRangeException

charCount or byteCount is less than zero.

ArgumentException

byteCount is less than the resulting number of bytes.

EncoderFallbackException

A fallback occurred (for more information, see Character Encoding in .NET)

-and-

Fallback is set to EncoderExceptionFallback.

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

Source:

Encoder.cs

When overridden in a derived class, encodes a set of characters from the specified character array and any characters in the internal buffer into the specified byte array. A parameter indicates whether to clear the internal state of the encoder after the 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

Parameters

chars

Char[]

The character array containing the set of characters to encode.

charIndex

Int32

The index of the first character to encode.

charCount

Int32

The number of characters to encode.

bytes

Byte[]

The byte array to contain the resulting sequence of bytes.

byteIndex

Int32

The index at which to start writing the resulting sequence of bytes.

flush

Boolean

true to clear the internal state of the encoder after the conversion; otherwise, false.

Returns

Int32

The actual number of bytes written into bytes.

Exceptions

ArgumentNullException

chars is null (Nothing).

-or-

bytes is null (Nothing).

ArgumentOutOfRangeException

charIndex or charCount or byteIndex is less than zero.

-or-

charIndex and charCount do not denote a valid range in chars.

-or-

byteIndex is not a valid index in bytes.

ArgumentException

bytes does not have enough capacity from byteIndex to the end of the array to accommodate the resulting bytes.

EncoderFallbackException

A fallback occurred (for more information, see Character Encoding in .NET)

-and-

Fallback is set to EncoderExceptionFallback.

Examples

The following example demonstrates how to encode a range of elements from a character array and store the encoded bytes in a range of elements in a byte array. The GetByteCount method is used to determine the size of the array required by 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]
'