BitConverter.ToUInt32 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
| ToUInt32(ReadOnlySpan<Byte>) |
Converts a read-only byte span into a 32-bit unsigned integer. |
| ToUInt32(Byte[], Int32) |
Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array. |
ToUInt32(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 32-bit unsigned integer.
public:
static System::UInt32 ToUInt32(ReadOnlySpan<System::Byte> value);[System.CLSCompliant(false)]
public static uint ToUInt32 (ReadOnlySpan<byte> value);[<System.CLSCompliant(false)>]
static member ToUInt32 : ReadOnlySpan<byte> -> uint32Public Shared Function ToUInt32 (value As ReadOnlySpan(Of Byte)) As UIntegerParameters
- value
- ReadOnlySpan<Byte>
A read-only span containing the bytes to convert.
Returns
A 32-bit unsigned integer representing the converted bytes.
- Attributes
Exceptions
The length of value is less than 4.
Applies to
ToUInt32(Byte[], Int32)
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
Important
This API is not CLS-compliant.
Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.
public:
static System::UInt32 ToUInt32(cli::array <System::Byte> ^ value, int startIndex);[System.CLSCompliant(false)]
public static uint ToUInt32 (byte[] value, int startIndex);[<System.CLSCompliant(false)>]
static member ToUInt32 : byte[] * int -> uint32Public Shared Function ToUInt32 (value As Byte(), startIndex As Integer) As UIntegerParameters
- value
- Byte[]
An array of bytes.
- startIndex
- Int32
The starting position within value.
Returns
A 32-bit unsigned integer formed by four bytes beginning at startIndex.
- Attributes
Exceptions
startIndex is greater than or equal to the length of value minus 3, and is less than or equal to 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 UInt32 values with the ToUInt32 method.
// Example of the BitConverter::ToUInt32 method.
using namespace System;
// Convert four byte array elements to an unsigned int and display it.
void BAToUInt32( array<unsigned char>^bytes, int index )
{
unsigned int value = BitConverter::ToUInt32( bytes, index );
Console::WriteLine( "{0,5}{1,17}{2,15}", index, BitConverter::ToString( bytes, index, 4 ), value );
}
int main()
{
array<unsigned char>^byteArray = {15,0,0,0,0,16,0,255,3,0,0,202,154,59,255,255,255,255,127};
Console::WriteLine( "This example of the BitConverter::ToUInt32( unsigned "
"char[ ], int ) \nmethod generates the following output. It "
"converts elements of a \nbyte array to unsigned int "
"values.\n" );
Console::WriteLine( "initial byte array" );
Console::WriteLine( "------------------" );
Console::WriteLine( BitConverter::ToString( byteArray ) );
Console::WriteLine();
Console::WriteLine( "{0,5}{1,17}{2,15}", "index", "array elements", "unsigned int" );
Console::WriteLine( "{0,5}{1,17}{2,15}", "-----", "--------------", "------------" );
// Convert byte array elements to unsigned int values.
BAToUInt32( byteArray, 1 );
BAToUInt32( byteArray, 0 );
BAToUInt32( byteArray, 7 );
BAToUInt32( byteArray, 3 );
BAToUInt32( byteArray, 10 );
BAToUInt32( byteArray, 15 );
BAToUInt32( byteArray, 14 );
}
/*
This example of the BitConverter::ToUInt32( unsigned char[ ], int )
method generates the following output. It converts elements of a
byte array to unsigned int values.
initial byte array
------------------
0F-00-00-00-00-10-00-FF-03-00-00-CA-9A-3B-FF-FF-FF-FF-7F
index array elements unsigned int
----- -------------- ------------
1 00-00-00-00 0
0 0F-00-00-00 15
7 FF-03-00-00 1023
3 00-00-10-00 1048576
10 00-CA-9A-3B 1000000000
15 FF-FF-FF-7F 2147483647
14 FF-FF-FF-FF 4294967295
*/
// Example of the BitConverter.ToUInt32 method.
using System;
class BytesToUInt32Demo
{
const string formatter = "{0,5}{1,17}{2,15}";
// Convert four byte array elements to a uint and display it.
public static void BAToUInt32( byte[ ] bytes, int index )
{
uint value = BitConverter.ToUInt32( bytes, index );
Console.WriteLine( formatter, index,
BitConverter.ToString( bytes, index, 4 ), value );
}
public static void Main( )
{
byte[ ] byteArray = {
15, 0, 0, 0, 0, 16, 0, 255, 3, 0,
0, 202, 154, 59, 255, 255, 255, 255, 127 };
Console.WriteLine(
"This example of the BitConverter.ToUInt32( byte[ ], " +
"int ) \nmethod generates the following output. It " +
"converts elements \nof a byte array to uint values.\n" );
Console.WriteLine( "initial byte array" );
Console.WriteLine( "------------------" );
Console.WriteLine( BitConverter.ToString( byteArray ) );
Console.WriteLine( );
Console.WriteLine( formatter, "index", "array elements",
"uint" );
Console.WriteLine( formatter, "-----", "--------------",
"----" );
// Convert byte array elements to uint values.
BAToUInt32( byteArray, 1 );
BAToUInt32( byteArray, 0 );
BAToUInt32( byteArray, 7 );
BAToUInt32( byteArray, 3 );
BAToUInt32( byteArray, 10 );
BAToUInt32( byteArray, 15 );
BAToUInt32( byteArray, 14 );
}
}
/*
This example of the BitConverter.ToUInt32( byte[ ], int )
method generates the following output. It converts elements
of a byte array to uint values.
initial byte array
------------------
0F-00-00-00-00-10-00-FF-03-00-00-CA-9A-3B-FF-FF-FF-FF-7F
index array elements uint
----- -------------- ----
1 00-00-00-00 0
0 0F-00-00-00 15
7 FF-03-00-00 1023
3 00-00-10-00 1048576
10 00-CA-9A-3B 1000000000
15 FF-FF-FF-7F 2147483647
14 FF-FF-FF-FF 4294967295
*/
open System
let print obj1 obj2 obj3 = printfn $"{obj1,5}{obj2,17}{obj3,15}"
// Convert four byte array elements to a uint and display it.
let BAToUInt32 bytes index =
let value = BitConverter.ToUInt32(bytes, index)
print index (BitConverter.ToString(bytes, index, 4)) value
let byteArray =
[| 15uy; 0uy; 0uy; 0uy; 0uy; 16uy; 0uy; 255uy; 3uy; 0uy
0uy; 202uy; 154uy; 59uy; 255uy; 255uy; 255uy; 255uy; 127uy |]
printfn "This example of the BitConverter.ToUInt32(byte [], int) \nmethod generates the following output. It converts elements \nof a byte array to uint values.\n"
printfn "initial byte array"
printfn "------------------"
printfn $"{BitConverter.ToString byteArray}\n"
print "index" "array elements" "uint"
print "-----" "--------------" "----"
// Convert byte array elements to uint values.
BAToUInt32 byteArray 1
BAToUInt32 byteArray 0
BAToUInt32 byteArray 7
BAToUInt32 byteArray 3
BAToUInt32 byteArray 10
BAToUInt32 byteArray 15
BAToUInt32 byteArray 14
// This example of the BitConverter.ToUInt32(byte [], int)
// method generates the following output. It converts elements
// of a byte array to uint values.
//
// initial byte array
// ------------------
// 0F-00-00-00-00-10-00-FF-03-00-00-CA-9A-3B-FF-FF-FF-FF-7F
//
// index array elements uint
// ----- -------------- ----
// 1 00-00-00-00 0
// 0 0F-00-00-00 15
// 7 FF-03-00-00 1023
// 3 00-00-10-00 1048576
// 10 00-CA-9A-3B 1000000000
// 15 FF-FF-FF-7F 2147483647
// 14 FF-FF-FF-FF 4294967295
' Example of the BitConverter.ToUInt32 method.
Module BytesToUInt32Demo
Const formatter As String = "{0,5}{1,17}{2,15}"
' Convert four Byte array elements to a UInt32 and display it.
Sub BAToUInt32( bytes( ) As Byte, index As Integer )
Dim value As UInt32 = BitConverter.ToUInt32( bytes, index )
Console.WriteLine( formatter, index, _
BitConverter.ToString( bytes, index, 4 ), value )
End Sub
Sub Main( )
Dim byteArray as Byte( ) = { _
15, 0, 0, 0, 0, 16, 0, 255, 3, 0, _
0, 202, 154, 59, 255, 255, 255, 255, 127 }
Console.WriteLine( _
"This example of the BitConverter.ToUInt32( Byte( ), " & _
"Integer ) " & vbCrLf & "method generates the " & _
"following output. It converts elements " & vbCrLf & _
"of a Byte array to UInt32 values." & vbCrLf )
Console.WriteLine( "initial Byte array" )
Console.WriteLine( "------------------" )
Console.WriteLine( BitConverter.ToString( byteArray ) )
Console.WriteLine( )
Console.WriteLine( formatter, "index", "array elements", _
"UInt32" )
Console.WriteLine( formatter, "-----", "--------------", _
"------" )
' Convert Byte array elements to UInt32 values.
BAToUInt32( byteArray, 1 )
BAToUInt32( byteArray, 0 )
BAToUInt32( byteArray, 7 )
BAToUInt32( byteArray, 3 )
BAToUInt32( byteArray, 10 )
BAToUInt32( byteArray, 15 )
BAToUInt32( byteArray, 14 )
End Sub
End Module
' This example of the BitConverter.ToUInt32( Byte( ), Integer )
' method generates the following output. It converts elements
' of a Byte array to UInt32 values.
'
' initial Byte array
' ------------------
' 0F-00-00-00-00-10-00-FF-03-00-00-CA-9A-3B-FF-FF-FF-FF-7F
'
' index array elements UInt32
' ----- -------------- ------
' 1 00-00-00-00 0
' 0 0F-00-00-00 15
' 7 FF-03-00-00 1023
' 3 00-00-10-00 1048576
' 10 00-CA-9A-3B 1000000000
' 15 FF-FF-FF-7F 2147483647
' 14 FF-FF-FF-FF 4294967295
Remarks
The ToUInt32 method converts the bytes from index startIndex to startIndex + 3 to a UInt32 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
Berkolaborasi dengan kami di GitHub
Sumber untuk konten ini dapat ditemukan di GitHub, yang juga dapat Anda gunakan untuk membuat dan meninjau masalah dan menarik permintaan. Untuk informasi selengkapnya, lihat panduan kontributor kami.
