BitConverter.ToUInt16 Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Overloads
| ToUInt16(ReadOnlySpan<Byte>) |
Converts a read-only byte-span into a 16-bit unsigned integer. |
| ToUInt16(Byte[], Int32) |
Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array. |
ToUInt16(ReadOnlySpan<Byte>)
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
Important
This API is not CLS-compliant.
Converts a read-only byte-span into a 16-bit unsigned integer.
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 UShortParameters
- value
- ReadOnlySpan<Byte>
A read-only span containing the bytes to convert.
Returns
An 16-bit unsigned integer representing the converted bytes.
- Attributes
Exceptions
The length of value is less than 2.
Applies to
ToUInt16(Byte[], Int32)
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
Important
This API is not CLS-compliant.
Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.
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 UShortParameters
- value
- Byte[]
The array of bytes that includes the two bytes to convert.
- startIndex
- Int32
The starting position within value.
Returns
A 16-bit unsigned integer formed by two bytes beginning at startIndex.
- Attributes
Exceptions
startIndex equals the length of value minus 1.
value is null.
startIndex is less than zero or greater than the length of value minus 1.
Examples
The following code example converts elements of Byte arrays to UInt16 values with the ToUInt16 method.
// 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
Remarks
The ToUInt16 method converts the bytes from index startIndex to startIndex + 1 to a UInt16 value. The order of bytes in the array must reflect the endianness of the computer system's architecture. For more information, see the Remarks section of the BitConverter class topic.
See also
Applies to
Collaborate with us on GitHub
The source for this content can be found on GitHub, where you can also create and review issues and pull requests. For more information, see our contributor guide.
Feedback
Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback.
Submit and view feedback for