BitConverter.ToInt16 Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.Extensions.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Sobrecargas

ToInt16(Byte[], Int32)	Devuelve un entero de 16 bits con signo convertido a partir de dos bytes en la posición especificada de una matriz de bytes.
ToInt16(ReadOnlySpan<Byte>)	Convierte un intervalo de bytes de solo lectura en un entero de 16 bits con signo.

ToInt16(Byte[], Int32)

Devuelve un entero de 16 bits con signo convertido a partir de dos bytes en la posición especificada de una matriz de bytes.

public:
 static short ToInt16(cli::array <System::Byte> ^ value, int startIndex);

public static short ToInt16 (byte[] value, int startIndex);

static member ToInt16 : byte[] * int -> int16

Public Shared Function ToInt16 (value As Byte(), startIndex As Integer) As Short

Parámetros

value: Byte[]

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

startIndex: Int32

Posición inicial de value.

Devoluciones

Int16

Entero de 16 bits con signo formado por dos bytes que comienzan en startIndex.

Excepciones

ArgumentException

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

ArgumentNullException

value es null.

ArgumentOutOfRangeException

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 Int16 valores con el ToInt16 método .

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

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

int main()
{
   array<unsigned char>^byteArray = {15,0,0,128,16,39,240,216,241,255,127};
   Console::WriteLine( "This example of the BitConverter::ToInt16( unsigned "
   "char[ ], int ) \nmethod generates the following output. It "
   "converts elements of a \nbyte array to short values.\n" );
   Console::WriteLine( "initial byte array" );
   Console::WriteLine( "------------------" );
   Console::WriteLine( BitConverter::ToString( byteArray ) );
   Console::WriteLine();
   Console::WriteLine( "{0,5}{1,17}{2,10}", "index", "array elements", "short" );
   Console::WriteLine( "{0,5}{1,17}{2,10}", "-----", "--------------", "-----" );
   
   // Convert byte array elements to short values.
   BAToInt16( byteArray, 1 );
   BAToInt16( byteArray, 0 );
   BAToInt16( byteArray, 8 );
   BAToInt16( byteArray, 4 );
   BAToInt16( byteArray, 6 );
   BAToInt16( byteArray, 9 );
   BAToInt16( byteArray, 2 );
}

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

initial byte array
------------------
0F-00-00-80-10-27-F0-D8-F1-FF-7F

index   array elements     short
-----   --------------     -----
    1            00-00         0
    0            0F-00        15
    8            F1-FF       -15
    4            10-27     10000
    6            F0-D8    -10000
    9            FF-7F     32767
    2            00-80    -32768
*/

// Example of the BitConverter.ToInt16 method.
using System;

class BytesToInt16Demo
{
    const string formatter = "{0,5}{1,17}{2,10}";

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

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

    public static void Main( )
    {
        byte[ ] byteArray =
            { 15, 0, 0, 128, 16, 39, 240, 216, 241, 255, 127 };

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

        // Convert byte array elements to short values.
        BAToInt16( byteArray, 1 );
        BAToInt16( byteArray, 0 );
        BAToInt16( byteArray, 8 );
        BAToInt16( byteArray, 4 );
        BAToInt16( byteArray, 6 );
        BAToInt16( byteArray, 9 );
        BAToInt16( byteArray, 2 );
    }
}

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

initial byte array
------------------
0F-00-00-80-10-27-F0-D8-F1-FF-7F

index   array elements     short
-----   --------------     -----
    1            00-00         0
    0            0F-00        15
    8            F1-FF       -15
    4            10-27     10000
    6            F0-D8    -10000
    9            FF-7F     32767
    2            00-80    -32768
*/

open System

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

// Convert two byte array elements to a short and display it.
let BAToInt16 bytes index =
    let value = BitConverter.ToInt16(bytes, index)

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

let byteArray =
    [| 15uy; 0uy; 0uy; 128uy; 16uy; 39uy; 240uy; 216uy; 241uy; 255uy; 127uy |]

printfn "This example of the BitConverter.ToInt16(byte [], int) \nmethod generates the following output. It converts elements \nof a byte array to short values.\n"
printfn "initial byte array"
printfn "------------------"
printfn $"{BitConverter.ToString byteArray}\n"
print "index" "array elements" "short"
print "-----" "--------------" "-----"

// Convert byte array elements to short values.
BAToInt16 byteArray 1
BAToInt16 byteArray 0
BAToInt16 byteArray 8
BAToInt16 byteArray 4
BAToInt16 byteArray 6
BAToInt16 byteArray 9
BAToInt16 byteArray 2


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

// initial byte array
// ------------------
// 0F-00-00-80-10-27-F0-D8-F1-FF-7F

// index   array elements     short
// -----   --------------     -----
//     1            00-00         0
//     0            0F-00        15
//     8            F1-FF       -15
//     4            10-27     10000
//     6            F0-D8    -10000
//     9            FF-7F     32767
//     2            00-80    -32768

' Example of the BitConverter.ToInt16 method.
Module BytesToInt16Demo

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

        Dim value As Short = BitConverter.ToInt16( bytes, index )

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

        Dim byteArray as Byte( ) = { _
             15, 0, 0, 128, 16, 39, 240, 216, 241, 255, 127 }

        Console.WriteLine( _
            "This example of the BitConverter.ToInt16( Byte( ), " & _
            "Integer ) " & vbCrLf & "method generates the " & _
            "following output. It converts elements " & vbCrLf & _
            "of a Byte array to Short values." & vbCrLf )
        Console.WriteLine( "initial Byte array" )
        Console.WriteLine( "------------------" )
        Console.WriteLine( BitConverter.ToString( byteArray ) )
        Console.WriteLine( )
        Console.WriteLine( formatter, "index", "array elements", "Short" )
        Console.WriteLine( formatter, "-----", "--------------", "-----" )
          
        ' Convert Byte array elements to Short values.
        BAToInt16( byteArray, 1 )
        BAToInt16( byteArray, 0 )
        BAToInt16( byteArray, 8 )
        BAToInt16( byteArray, 4 )
        BAToInt16( byteArray, 6 )
        BAToInt16( byteArray, 9 )
        BAToInt16( byteArray, 2 )
    End Sub 
End Module

' This example of the BitConverter.ToInt16( Byte( ), Integer )
' method generates the following output. It converts elements
' of a Byte array to Short values.
' 
' initial Byte array
' ------------------
' 0F-00-00-80-10-27-F0-D8-F1-FF-7F
' 
' index   array elements     Short
' -----   --------------     -----
'     1            00-00         0
'     0            0F-00        15
'     8            F1-FF       -15
'     4            10-27     10000
'     6            F0-D8    -10000
'     9            FF-7F     32767
'     2            00-80    -32768

Comentarios

El ToInt16 método convierte los bytes del índice startIndex a startIndex + 1 en un Int16 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

GetBytes(Int16)

Se aplica a

ToInt16(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 16 bits con signo.

public:
 static short ToInt16(ReadOnlySpan<System::Byte> value);

public static short ToInt16 (ReadOnlySpan<byte> value);

static member ToInt16 : ReadOnlySpan<byte> -> int16

Public Shared Function ToInt16 (value As ReadOnlySpan(Of Byte)) As Short

Parámetros

value: ReadOnlySpan<Byte>

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

Devoluciones

Int16

Entero de 16 bits con signo que representa los bytes convertidos.

Excepciones

ArgumentOutOfRangeException

La longitud de value es menor que 2.

Se aplica a

Comparteix a través de

BitConverter.ToInt16 Método

Definición

Sobrecargas

ToInt16(Byte[], Int32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

ToInt16(ReadOnlySpan<Byte>)

Parámetros

Devoluciones

Excepciones

Se aplica a

Recursos addicionals