BitConverter.ToUInt16 Método
Definición
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
| ToUInt16(ReadOnlySpan<Byte>) |
Convierte un intervalo de bytes de solo lectura en un entero de 16 bits sin signo. |
| ToUInt16(Byte[], Int32) |
Devuelve un entero de 16 bits sin signo convertido a partir de dos bytes en la posición especificada de una matriz de bytes. |
ToUInt16(ReadOnlySpan<Byte>)
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
Importante
Esta API no es conforme a CLS.
Convierte un intervalo de bytes de solo lectura en un entero de 16 bits sin signo.
public:
static System::UInt16 ToUInt16(ReadOnlySpan<System::Byte> value);[System.CLSCompliant(false)]
public static ushort ToUInt16 (ReadOnlySpan<byte> value);[<System.CLSCompliant(false)>]
static member ToUInt16 : ReadOnlySpan<byte> -> uint16Public Shared Function ToUInt16 (value As ReadOnlySpan(Of Byte)) As UShortParámetros
- value
- ReadOnlySpan<Byte>
Intervalo de solo lectura que contiene los bytes que se van a convertir.
Devoluciones
Entero de 16 bits sin signo que representa los bytes convertidos.
- Atributos
Excepciones
La longitud de value es menor que 2.
Se aplica a
ToUInt16(Byte[], Int32)
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
Importante
Esta API no es conforme a CLS.
Devuelve un entero de 16 bits sin signo convertido a partir de dos bytes en la posición especificada de una matriz de bytes.
public:
static System::UInt16 ToUInt16(cli::array <System::Byte> ^ value, int startIndex);[System.CLSCompliant(false)]
public static ushort ToUInt16 (byte[] value, int startIndex);[<System.CLSCompliant(false)>]
static member ToUInt16 : byte[] * int -> uint16Public Shared Function ToUInt16 (value As Byte(), startIndex As Integer) As UShortParámetros
- value
- Byte[]
Matriz de bytes que incluye los dos bytes que se van a convertir.
- startIndex
- Int32
Posición inicial de value.
Devoluciones
Entero de 16 bits sin signo formado por dos bytes que comienzan en startIndex.
- Atributos
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 UInt16 valores con el ToUInt16 método .
// Example of the BitConverter::ToUInt16 method.
using namespace System;
// Convert two byte array elements to an unsigned short and display it.
void BAToUInt16( array<unsigned char>^bytes, int index )
{
unsigned short value = BitConverter::ToUInt16( bytes, index );
Console::WriteLine( "{0,5}{1,17}{2,16}", index, BitConverter::ToString( bytes, index, 2 ), value );
}
int main()
{
array<unsigned char>^byteArray = {15,0,0,255,3,16,39,255,255,127};
Console::WriteLine( "This example of the BitConverter::ToUInt16( unsigned "
"char[ ], int ) \nmethod generates the following output. It "
"converts elements of a \nbyte array to unsigned short "
"values.\n" );
Console::WriteLine( "initial byte array" );
Console::WriteLine( "------------------" );
Console::WriteLine( BitConverter::ToString( byteArray ) );
Console::WriteLine();
Console::WriteLine( "{0,5}{1,17}{2,16}", "index", "array elements", "unsigned short" );
Console::WriteLine( "{0,5}{1,17}{2,16}", "-----", "--------------", "--------------" );
// Convert byte array elements to unsigned short values.
BAToUInt16( byteArray, 1 );
BAToUInt16( byteArray, 0 );
BAToUInt16( byteArray, 3 );
BAToUInt16( byteArray, 5 );
BAToUInt16( byteArray, 8 );
BAToUInt16( byteArray, 7 );
}
/*
This example of the BitConverter::ToUInt16( unsigned char[ ], int )
method generates the following output. It converts elements of a
byte array to unsigned short values.
initial byte array
------------------
0F-00-00-FF-03-10-27-FF-FF-7F
index array elements unsigned short
----- -------------- --------------
1 00-00 0
0 0F-00 15
3 FF-03 1023
5 10-27 10000
8 FF-7F 32767
7 FF-FF 65535
*/
// Example of the BitConverter.ToUInt16 method.
using System;
class BytesToUInt16Demo
{
const string formatter = "{0,5}{1,17}{2,10}";
// Convert two byte array elements to a ushort and display it.
public static void BAToUInt16( byte[ ] bytes, int index )
{
ushort value = BitConverter.ToUInt16( bytes, index );
Console.WriteLine( formatter, index,
BitConverter.ToString( bytes, index, 2 ), value );
}
public static void Main( )
{
byte[] byteArray = {
15, 0, 0, 255, 3, 16, 39, 255, 255, 127 };
Console.WriteLine(
"This example of the BitConverter.ToUInt16( byte[ ], " +
"int ) \nmethod generates the following output. It " +
"converts elements \nof a byte array to ushort values.\n" );
Console.WriteLine( "initial byte array" );
Console.WriteLine( "------------------" );
Console.WriteLine( BitConverter.ToString( byteArray ) );
Console.WriteLine( );
Console.WriteLine( formatter, "index", "array elements",
"ushort" );
Console.WriteLine( formatter, "-----", "--------------",
"------" );
// Convert byte array elements to ushort values.
BAToUInt16( byteArray, 1 );
BAToUInt16( byteArray, 0 );
BAToUInt16( byteArray, 3 );
BAToUInt16( byteArray, 5 );
BAToUInt16( byteArray, 8 );
BAToUInt16( byteArray, 7 );
}
}
/*
This example of the BitConverter.ToUInt16( byte[ ], int )
method generates the following output. It converts elements
of a byte array to ushort values.
initial byte array
------------------
0F-00-00-FF-03-10-27-FF-FF-7F
index array elements ushort
----- -------------- ------
1 00-00 0
0 0F-00 15
3 FF-03 1023
5 10-27 10000
8 FF-7F 32767
7 FF-FF 65535
*/
open System
let print obj1 obj2 obj3 = printfn $"{obj1,5}{obj2,17}{obj3,10}"
// Convert two byte array elements to a ushort and display it.
let BAToUInt16 bytes index =
let value = BitConverter.ToUInt16(bytes, index)
print index (BitConverter.ToString(bytes, index, 2)) value
let byteArray =
[| 15uy; 0uy; 0uy; 255uy; 3uy; 16uy; 39uy; 255uy; 255uy; 127uy |]
printfn "This example of the BitConverter.ToUInt16(byte [], int) \nmethod generates the following output. It converts elements \nof a byte array to ushort values.\n"
printfn "initial byte array"
printfn "------------------"
printfn $"{BitConverter.ToString byteArray}\n"
print "index" "array elements" "ushort"
print "-----" "--------------" "------"
// Convert byte array elements to ushort values.
BAToUInt16 byteArray 1
BAToUInt16 byteArray 0
BAToUInt16 byteArray 3
BAToUInt16 byteArray 5
BAToUInt16 byteArray 8
BAToUInt16 byteArray 7
// This example of the BitConverter.ToUInt16(byte [], int)
// method generates the following output. It converts elements
// of a byte array to ushort values.
//
// initial byte array
// ------------------
// 0F-00-00-FF-03-10-27-FF-FF-7F
//
// index array elements ushort
// ----- -------------- ------
// 1 00-00 0
// 0 0F-00 15
// 3 FF-03 1023
// 5 10-27 10000
// 8 FF-7F 32767
// 7 FF-FF 65535
' Example of the BitConverter.ToUInt16 method.
Module BytesToUInt16Demo
Const formatter As String = "{0,5}{1,17}{2,10}"
' Convert two Byte array elements to a UInt16 and display it.
Sub BAToUInt16( bytes( ) As Byte, index As Integer )
Dim value As UInt16 = BitConverter.ToUInt16( bytes, index )
Console.WriteLine( formatter, index, _
BitConverter.ToString( bytes, index, 2 ), value )
End Sub
Sub Main( )
Dim byteArray as Byte( ) = { _
15, 0, 0, 255, 3, 16, 39, 255, 255, 127 }
Console.WriteLine( _
"This example of the BitConverter.ToUInt16( Byte( ), " & _
"Integer ) " & vbCrLf & "method generates the " & _
"following output. It converts elements " & vbCrLf & _
"of a Byte array to UInt16 values." & vbCrLf )
Console.WriteLine( "initial Byte array" )
Console.WriteLine( "------------------" )
Console.WriteLine( BitConverter.ToString( byteArray ) )
Console.WriteLine( )
Console.WriteLine( formatter, "index", "array elements", _
"UInt16" )
Console.WriteLine( formatter, "-----", "--------------", _
"------" )
' Convert Byte array elements to UInt16 values.
BAToUInt16( byteArray, 1 )
BAToUInt16( byteArray, 0 )
BAToUInt16( byteArray, 3 )
BAToUInt16( byteArray, 5 )
BAToUInt16( byteArray, 8 )
BAToUInt16( byteArray, 7 )
End Sub
End Module
' This example of the BitConverter.ToUInt16( Byte( ), Integer )
' method generates the following output. It converts elements
' of a Byte array to UInt16 values.
'
' initial Byte array
' ------------------
' 0F-00-00-FF-03-10-27-FF-FF-7F
'
' index array elements UInt16
' ----- -------------- ------
' 1 00-00 0
' 0 0F-00 15
' 3 FF-03 1023
' 5 10-27 10000
' 8 FF-7F 32767
' 7 FF-FF 65535
Comentarios
El ToUInt16 método convierte los bytes del índice startIndex en startIndex + 1 en un UInt16 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
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de