Compartir vía


BitConverter.ToChar Método

Definición

Sobrecargas

ToChar(Byte[], Int32)

Devuelve un carácter Unicode convertido a partir de dos bytes en la posición especificada de una matriz de bytes.

ToChar(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un carácter.

ToChar(Byte[], Int32)

Source:
BitConverter.cs
Source:
BitConverter.cs
Source:
BitConverter.cs

Devuelve un carácter Unicode convertido a partir de dos bytes en la posición especificada de una matriz de bytes.

public:
 static char ToChar(cli::array <System::Byte> ^ value, int startIndex);
public static char ToChar (byte[] value, int startIndex);
static member ToChar : byte[] * int -> char
Public Shared Function ToChar (value As Byte(), startIndex As Integer) As Char

Parámetros

value
Byte[]

Matriz que incluye los dos bytes que se van a convertir.

startIndex
Int32

Posición inicial de value.

Devoluciones

Carácter formado por dos bytes a partir de startIndex.

Excepciones

El parámetro startIndex es igual a la longitud de value menos 1.

value es null.

startIndex es menor que cero o mayor que la longitud de value menos 1.

Ejemplos

En el ejemplo de código siguiente se convierten elementos de Byte matrices en Char valores (caracteres Unicode) con el ToChar método .

// Example of the BitConverter::ToChar method.
using namespace System;

// Convert two byte array elements to a __wchar_t and display it.
void BAToChar( array<unsigned char>^bytes, int index )
{
   __wchar_t value = BitConverter::ToChar( bytes, index );
   Console::WriteLine( "{0,5}{1,17}{2,11}", index, BitConverter::ToString( bytes, index, 2 ), value );
}

int main()
{
   array<unsigned char>^byteArray = {32,0,0,42,0,65,0,125,0,197,0,168,3,41,4,172,32};
   Console::WriteLine( "This example of the BitConverter::ToChar( unsigned "
   "char[ ], int ) \nmethod generates the following output. It "
   "converts elements of a \nbyte array to __wchar_t values.\n" );
   Console::WriteLine( "initial unsigned char array" );
   Console::WriteLine( "---------------------------" );
   Console::WriteLine( BitConverter::ToString( byteArray ) );
   Console::WriteLine();
   Console::WriteLine( "{0,5}{1,17}{2,11}", "index", "array elements", "__wchar_t" );
   Console::WriteLine( "{0,5}{1,17}{2,11}", "-----", "--------------", "---------" );
   
   // Convert byte array elements to __wchar_t values.
   BAToChar( byteArray, 0 );
   BAToChar( byteArray, 1 );
   BAToChar( byteArray, 3 );
   BAToChar( byteArray, 5 );
   BAToChar( byteArray, 7 );
   BAToChar( byteArray, 9 );
   BAToChar( byteArray, 11 );
   BAToChar( byteArray, 13 );
   BAToChar( byteArray, 15 );
}

/*
This example of the BitConverter::ToChar(unsigned char[ ], int)
method generates the following output. It converts elements of a
byte array to __wchar_t values.

initial unsigned char array
---------------------------
20-00-00-2A-00-41-00-7D-00-C5-00-A8-03-29-04-AC-20

index   array elements  __wchar_t
-----   --------------  ---------
    0            20-00
    1            00-00
    3            2A-00          *
    5            41-00          A
    7            7D-00          }
    9            C5-00          Å
   11            A8-03          Ψ
   13            29-04          Щ
   15            AC-20          €
*/
// Example of the BitConverter.ToChar method.
using System;

class BytesToCharDemo
{
    const string formatter = "{0,5}{1,17}{2,8}";

    // Convert two byte array elements to a char and display it.
    public static void BAToChar( byte[] bytes, int index )
    {
        char value = BitConverter.ToChar( bytes, index );

        Console.WriteLine( formatter, index,
            BitConverter.ToString( bytes, index, 2 ), value );
    }

    public static void Main( )
    {
        byte[] byteArray = {
             32,   0,   0,  42,   0,  65,   0, 125,   0,
            197,   0, 168,   3,  41,   4, 172,  32 };

        Console.WriteLine(
            "This example of the BitConverter.ToChar( byte[ ], " +
            "int ) \nmethod generates the following output. It " +
            "converts \nelements of a byte array to char values.\n" );
        Console.WriteLine( "initial byte array" );
        Console.WriteLine( "------------------" );
        Console.WriteLine( BitConverter.ToString( byteArray ) );
        Console.WriteLine( );
        Console.WriteLine( formatter, "index", "array elements", "char" );
        Console.WriteLine( formatter, "-----", "--------------", "----" );

        // Convert byte array elements to char values.
        BAToChar( byteArray, 0 );
        BAToChar( byteArray, 1 );
        BAToChar( byteArray, 3 );
        BAToChar( byteArray, 5 );
        BAToChar( byteArray, 7 );
        BAToChar( byteArray, 9 );
        BAToChar( byteArray, 11 );
        BAToChar( byteArray, 13 );
        BAToChar( byteArray, 15 );
    }
}

/*
This example of the BitConverter.ToChar(byte[ ], int)
method generates the following output. It converts
elements of a byte array to char values.

initial byte array
------------------
20-00-00-2A-00-41-00-7D-00-C5-00-A8-03-29-04-AC-20

index   array elements    char
-----   --------------    ----
    0            20-00
    1            00-00
    3            2A-00       *
    5            41-00       A
    7            7D-00       }
    9            C5-00       Å
   11            A8-03       Ψ
   13            29-04       Щ
   15            AC-20       €
*/
open System

let print obj1 obj2 obj3 = printfn $"{obj1,5}{obj2,17}{obj3,8}"

// Convert two byte array elements to a char and display it.
let BAToChar bytes index =
    let value = BitConverter.ToChar(bytes, index)

    print index (BitConverter.ToString(bytes, index, 2)) value

let byteArray = 
    [| 32uy; 0uy; 0uy; 42uy; 0uy; 65uy; 0uy; 125uy; 0uy
       197uy; 0uy; 168uy; 3uy; 41uy; 4uy; 172uy; 32uy |]

printfn "This example of the BitConverter.ToChar(byte [], int) \nmethod generates the following output. It converts \nelements of a byte array to char values.\n"
printfn "initial byte array"
printfn "------------------"
printfn $"{BitConverter.ToString byteArray}\n"

print "index" "array elements" "char"
print "-----" "--------------" "----"

// Convert byte array elements to char values.
BAToChar byteArray 0
BAToChar byteArray 1
BAToChar byteArray 3
BAToChar byteArray 5
BAToChar byteArray 7
BAToChar byteArray 9
BAToChar byteArray 11
BAToChar byteArray 13
BAToChar byteArray 15


// This example of the BitConverter.ToChar(byte [], int)
// method generates the following output. It converts
// elements of a byte array to char values.
//
// initial byte array
// ------------------
// 20-00-00-2A-00-41-00-7D-00-C5-00-A8-03-29-04-AC-20
//
// index   array elements    char
// -----   --------------    ----
//     0            20-00
//     1            00-00
//     3            2A-00       *
//     5            41-00       A
//     7            7D-00       }
//     9            C5-00       Å
//    11            A8-03       Ψ
//    13            29-04       Щ
//    15            AC-20       €
' Example of the BitConverter.ToChar method.
Module BytesToCharDemo

    Const formatter As String = "{0,5}{1,17}{2,8}"
 
    ' Convert two Byte array elements to a Char and display it.
    Sub BAToChar( bytes( ) As Byte, index As Integer )

        Dim value As Char = BitConverter.ToChar( bytes, index )

        Console.WriteLine( formatter, index, _
            BitConverter.ToString( bytes, index, 2 ), value )
    End Sub 
       
    Sub Main( )

        Dim byteArray as Byte( ) = { _
             32,   0,   0,  42,   0,  65,   0, 125,   0, 197, _
              0, 168,   3,  41,   4, 172,  32 }

        Console.WriteLine( _
            "This example of the BitConverter.ToChar( Byte( ), " & _
            "Integer ) " & vbCrLf & "method generates the " & _
            "following output. It converts elements " & vbCrLf & _
            "of a Byte array to Char values." & vbCrLf )
        Console.WriteLine( "initial Byte array" )
        Console.WriteLine( "------------------" )
        Console.WriteLine( BitConverter.ToString( byteArray ) )
        Console.WriteLine( )
        Console.WriteLine( formatter, "index", "array elements", "Char" )
        Console.WriteLine( formatter, "-----", "--------------", "----" )
          
        ' Convert Byte array elements to Char values.
        BAToChar( byteArray, 0 )
        BAToChar( byteArray, 1 )
        BAToChar( byteArray, 3 )
        BAToChar( byteArray, 5 )
        BAToChar( byteArray, 7 )
        BAToChar( byteArray, 9 )
        BAToChar( byteArray, 11 )
        BAToChar( byteArray, 13 )
        BAToChar( byteArray, 15 )
    End Sub 
End Module

' This example of the BitConverter.ToChar( Byte( ), Integer )
' method generates the following output. It converts elements 
' of a Byte array to Char values.
' 
' initial Byte array
' ------------------
' 20-00-00-2A-00-41-00-7D-00-C5-00-A8-03-29-04-AC-20
'
' index   array elements    Char
' -----   --------------    ----
'     0            20-00
'     1            00-00
'     3            2A-00       *
'     5            41-00       A
'     7            7D-00       }
'     9            C5-00       Å
'    11            A8-03       Ψ
'    13            29-04       Щ
'    15            AC-20       €

Comentarios

El ToChar método convierte los bytes del índice startIndex a startIndex + 1 en un Char valor. El orden de bytes de la matriz debe reflejar la endianidad de la arquitectura del sistema informático. Para obtener más información, vea la sección Comentarios del tema de clase BitConverter .

Consulte también

Se aplica a

ToChar(ReadOnlySpan<Byte>)

Source:
BitConverter.cs
Source:
BitConverter.cs
Source:
BitConverter.cs

Convierte un intervalo de bytes de solo lectura en un carácter.

public:
 static char ToChar(ReadOnlySpan<System::Byte> value);
public static char ToChar (ReadOnlySpan<byte> value);
static member ToChar : ReadOnlySpan<byte> -> char
Public Shared Function ToChar (value As ReadOnlySpan(Of Byte)) As Char

Parámetros

value
ReadOnlySpan<Byte>

Intervalo de solo lectura que contiene los bytes que se van a convertir.

Devoluciones

Carácter que representa los bytes convertidos.

Excepciones

La longitud de value es menor que la longitud de un Char.

Se aplica a