BitConverter.ToUInt32 Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: System.Runtime.Extensions.dll

Ensamblado:: netstandard.dll

Ensamblado:: mscorlib.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

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

ToUInt32(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 32 bits sin signo.

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> -> uint32

Public Shared Function ToUInt32 (value As ReadOnlySpan(Of Byte)) As UInteger

Parámetros

value: ReadOnlySpan<Byte>

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

Devoluciones

UInt32

Entero de 32 bits sin signo que representa los bytes convertidos.

Atributos: CLSCompliantAttribute

Excepciones

ArgumentOutOfRangeException

La longitud de value es menor que 4.

Se aplica a

ToUInt32(Byte[], Int32)

Source:: BitConverter.cs

Source:: BitConverter.cs

Source:: BitConverter.cs

Importante

Esta API no es conforme a CLS.

Devuelve un entero de 32 bits sin signo convertido a partir de cuatro bytes en la posición especificada de una matriz de bytes.

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 -> uint32

Public Shared Function ToUInt32 (value As Byte(), startIndex As Integer) As UInteger

Parámetros

value: Byte[]

Matriz de bytes.

startIndex: Int32

Posición inicial de value.

Devoluciones

UInt32

Entero de 32 bits sin signo formado por cuatro bytes que comienzan en startIndex.

Atributos: CLSCompliantAttribute

Excepciones

ArgumentException

El parámetro startIndex es mayor o igual que la longitud de value menos 3 y es menor o igual que 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 UInt32 valores con el ToUInt32 método .

// 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

Comentarios

El ToUInt32 método convierte los bytes del índice startIndex en startIndex + 3 en un UInt32 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(UInt32)

Se aplica a

Compartir vía

BitConverter.ToUInt32 Método

Definición

Sobrecargas

ToUInt32(ReadOnlySpan<Byte>)

Parámetros

Devoluciones

Excepciones

Se aplica a

ToUInt32(Byte[], Int32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales