BitConverter.ToUInt32 Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Überlädt
| ToUInt32(ReadOnlySpan<Byte>) |
Konvertiert eine schreibgeschützte Bytespanne in einen 32-Bit-Integerwert ohne Vorzeichen. |
| ToUInt32(Byte[], Int32) |
Gibt eine vorzeichenlose 32-Bit-Ganzzahl zurück, die aus vier Bytes an der angegebenen Position in einem Bytearray konvertiert wurde. |
ToUInt32(ReadOnlySpan<Byte>)
- Quelle:
- BitConverter.cs
- Quelle:
- BitConverter.cs
- Quelle:
- BitConverter.cs
Wichtig
Diese API ist nicht CLS-kompatibel.
Konvertiert eine schreibgeschützte Bytespanne in einen 32-Bit-Integerwert ohne Vorzeichen.
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 UIntegerParameter
- value
- ReadOnlySpan<Byte>
Eine schreibgeschützte Spanne, die die zu konvertierenden Bytes enthält.
Gibt zurück
Ein 32-Bit-Integerwert ohne Vorzeichen, der die konvertierten Bytes darstellt.
- Attribute
Ausnahmen
Die Länge von value ist kleiner als 4.
Gilt für:
ToUInt32(Byte[], Int32)
- Quelle:
- BitConverter.cs
- Quelle:
- BitConverter.cs
- Quelle:
- BitConverter.cs
Wichtig
Diese API ist nicht CLS-kompatibel.
Gibt eine vorzeichenlose 32-Bit-Ganzzahl zurück, die aus vier Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.
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 UIntegerParameter
- value
- Byte[]
Ein Bytearray.
- startIndex
- Int32
Die Anfangsposition in value.
Gibt zurück
Eine vorzeichenlose 32-Bit-Ganzzahl, die beginnend bei startIndex aus vier Bytes gebildet wird.
- Attribute
Ausnahmen
startIndex ist größer oder gleich der Länge von value minus 3 und ist kleiner oder gleich der Länge von value minus 1.
value ist null.
startIndex ist kleiner als 0 (null) oder größer als die Länge von value minus 1.
Beispiele
Im folgenden Codebeispiel werden Elemente von Byte Arrays mit der ToUInt32 -Methode in UInt32 Werte konvertiert.
// 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
Hinweise
Die ToUInt32 -Methode konvertiert die Bytes aus dem Index startIndex in startIndex + 3 in einen UInt32 Wert. Die Reihenfolge der Bytes im Array muss die Endianität der Architektur des Computersystems widerspiegeln. Weitere Informationen finden Sie im Abschnitt Hinweise des BitConverter Klassenthemas.
Weitere Informationen
Gilt für:
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für