Condividi tramite


BitConverter.ToUInt64 Metodo

Definizione

Overload

ToUInt64(Byte[], Int32)

Restituisce un intero senza segno a 64 bit convertito da otto byte nella posizione specificata in una matrice di byte.

ToUInt64(ReadOnlySpan<Byte>)

Converte i byte in un valore long senza segno.

ToUInt64(Byte[], Int32)

Importante

Questa API non è conforme a CLS.

Restituisce un intero senza segno a 64 bit convertito da otto byte nella posizione specificata in una matrice di byte.

public:
 static System::UInt64 ToUInt64(cli::array <System::Byte> ^ value, int startIndex);
[System.CLSCompliant(false)]
public static ulong ToUInt64 (byte[] value, int startIndex);
[<System.CLSCompliant(false)>]
static member ToUInt64 : byte[] * int -> uint64
Public Shared Function ToUInt64 (value As Byte(), startIndex As Integer) As ULong

Parametri

value
Byte[]

Matrice di byte che include gli otto byte da convertire.

startIndex
Int32

Posizione iniziale all'interno di value.

Restituisce

UInt64

Un intero senza segno a 64 bit formato da otto byte a partire da startIndex.

Attributi

Eccezioni

startIndex è maggiore o uguale alla lunghezza di value meno 7 e minore o uguale alla lunghezza di value meno 1.

value è null.

startIndexè minore di zero o maggiore della lunghezza di value meno 1.

Esempio

Nell'esempio di codice seguente vengono convertiti elementi di Byte matrici in UInt64 valori con il ToUInt64 metodo .

// Example of the BitConverter::ToUInt64 method.
using namespace System;

// Convert eight byte array elements to an unsigned __int64 value and 
// display it.
void BAToUInt64( array<unsigned char>^bytes, int index )
{
   unsigned __int64 value = BitConverter::ToUInt64( bytes, index );
   Console::WriteLine( "{0,5}{1,27}{2,24}", index, BitConverter::ToString( bytes, index, 8 ), value );
}


// Display a byte array, using multiple lines if necessary.
void WriteMultiLineByteArray( array<unsigned char>^bytes )
{
   const int rowSize = 20;
   int iter;
   Console::WriteLine( "initial unsigned char array" );
   Console::WriteLine( "---------------------------" );
   for ( iter = 0; iter < bytes->Length - rowSize; iter += rowSize )
   {
      Console::Write( BitConverter::ToString( bytes, iter, rowSize ) );
      Console::WriteLine( "-" );

   }
   Console::WriteLine( BitConverter::ToString( bytes, iter ) );
   Console::WriteLine();
}

int main()
{
   array<unsigned char>^byteArray = {255,255,255,0,0,0,0,0,0,0,0,1,0,0,0,100,167,179,182,224,13,0,202,154,59,0,0,0,0,170,170,170,170,170,170,0,0,232,137,4,35,199,138,255,255,255,255,255,255,255,255,127};
   Console::WriteLine( "This example of the BitConverter::ToUInt64( unsigned "
   "char[ ], int ) \nmethod generates the following output. It "
   "converts elements of a \nbyte array to unsigned __int64 "
   "values.\n" );
   WriteMultiLineByteArray( byteArray );
   Console::WriteLine( "{0,5}{1,27}{2,24}", "index", "array elements", "unsigned __int64" );
   Console::WriteLine( "{0,5}{1,27}{2,24}", "-----", "--------------", "----------------" );
   
   // Convert byte array elements to unsigned __int64 values.
   BAToUInt64( byteArray, 3 );
   BAToUInt64( byteArray, 0 );
   BAToUInt64( byteArray, 21 );
   BAToUInt64( byteArray, 7 );
   BAToUInt64( byteArray, 29 );
   BAToUInt64( byteArray, 13 );
   BAToUInt64( byteArray, 35 );
   BAToUInt64( byteArray, 44 );
   BAToUInt64( byteArray, 43 );
}

/*
This example of the BitConverter::ToUInt64( unsigned char[ ], int )
method generates the following output. It converts elements of a
byte array to unsigned __int64 values.

initial unsigned char array
---------------------------
FF-FF-FF-00-00-00-00-00-00-00-00-01-00-00-00-64-A7-B3-B6-E0-
0D-00-CA-9A-3B-00-00-00-00-AA-AA-AA-AA-AA-AA-00-00-E8-89-04-
23-C7-8A-FF-FF-FF-FF-FF-FF-FF-FF-7F

index             array elements        unsigned __int64
-----             --------------        ----------------
    3    00-00-00-00-00-00-00-00                       0
    0    FF-FF-FF-00-00-00-00-00                16777215
   21    00-CA-9A-3B-00-00-00-00              1000000000
    7    00-00-00-00-01-00-00-00              4294967296
   29    AA-AA-AA-AA-AA-AA-00-00         187649984473770
   13    00-00-64-A7-B3-B6-E0-0D     1000000000000000000
   35    00-00-E8-89-04-23-C7-8A    10000000000000000000
   44    FF-FF-FF-FF-FF-FF-FF-7F     9223372036854775807
   43    FF-FF-FF-FF-FF-FF-FF-FF    18446744073709551615
*/
// Example of the BitConverter.ToUInt64 method.
using System;

class BytesToUInt64Demo
{
    const string formatter = "{0,5}{1,27}{2,24}";

    // Convert eight byte array elements to a ulong and display it.
    public static void BAToUInt64( byte[ ] bytes, int index )
    {
        ulong value = BitConverter.ToUInt64( bytes, index );

        Console.WriteLine( formatter, index,
            BitConverter.ToString( bytes, index, 8 ), value );
    }

    // Display a byte array, using multiple lines if necessary.
    public static void WriteMultiLineByteArray( byte[ ] bytes )
    {
        const int rowSize = 20;
        int iter;

        Console.WriteLine( "initial byte array" );
        Console.WriteLine( "------------------" );

        for( iter = 0; iter < bytes.Length - rowSize; iter += rowSize )
        {
            Console.Write(
                BitConverter.ToString( bytes, iter, rowSize ) );
            Console.WriteLine( "-" );
        }

        Console.WriteLine( BitConverter.ToString( bytes, iter ) );
        Console.WriteLine( );
    }

    public static void Main( )
    {
        byte[ ] byteArray = {
            255, 255, 255,   0,   0,   0,   0,   0,   0,   0,
              0,   1,   0,   0,   0, 100, 167, 179, 182, 224,
             13,   0, 202, 154,  59,   0,   0,   0,   0, 170,
            170, 170, 170, 170, 170,   0,   0, 232, 137,   4,
             35, 199, 138, 255, 255, 255, 255, 255, 255, 255,
            255, 127 };

        Console.WriteLine(
            "This example of the BitConverter.ToUInt64( byte[ ], " +
            "int ) \nmethod generates the following output. It " +
            "converts elements \nof a byte array to ulong values.\n" );

        WriteMultiLineByteArray( byteArray );

        Console.WriteLine( formatter, "index", "array elements",
            "ulong" );
        Console.WriteLine( formatter, "-----", "--------------",
            "------" );

        // Convert byte array elements to ulong values.
        BAToUInt64( byteArray, 3 );
        BAToUInt64( byteArray, 0 );
        BAToUInt64( byteArray, 21 );
        BAToUInt64( byteArray, 7 );
        BAToUInt64( byteArray, 29 );
        BAToUInt64( byteArray, 13 );
        BAToUInt64( byteArray, 35 );
        BAToUInt64( byteArray, 44 );
        BAToUInt64( byteArray, 43 );
    }
}

/*
This example of the BitConverter.ToUInt64( byte[ ], int )
method generates the following output. It converts elements
of a byte array to ulong values.

initial byte array
------------------
FF-FF-FF-00-00-00-00-00-00-00-00-01-00-00-00-64-A7-B3-B6-E0-
0D-00-CA-9A-3B-00-00-00-00-AA-AA-AA-AA-AA-AA-00-00-E8-89-04-
23-C7-8A-FF-FF-FF-FF-FF-FF-FF-FF-7F

index             array elements                   ulong
-----             --------------                  ------
    3    00-00-00-00-00-00-00-00                       0
    0    FF-FF-FF-00-00-00-00-00                16777215
   21    00-CA-9A-3B-00-00-00-00              1000000000
    7    00-00-00-00-01-00-00-00              4294967296
   29    AA-AA-AA-AA-AA-AA-00-00         187649984473770
   13    00-00-64-A7-B3-B6-E0-0D     1000000000000000000
   35    00-00-E8-89-04-23-C7-8A    10000000000000000000
   44    FF-FF-FF-FF-FF-FF-FF-7F     9223372036854775807
   43    FF-FF-FF-FF-FF-FF-FF-FF    18446744073709551615
*/
open System

let print obj1 obj2 obj3 = printfn $"{obj1,5}{obj2,27}{obj3,24}"

// Convert eight byte array elements to a ulong and display it.
let BAToUInt64 bytes index =
    let value = BitConverter.ToUInt64(bytes, index)

    print index (BitConverter.ToString(bytes, index, 8)) value

// Display a byte array, using multiple lines if necessary.
let writeMultiLineByteArray (bytes: byte []) =
    let rowSize = 20

    printfn "initial byte array"
    printfn "------------------"

    let mutable iter = 0
    for i in 0 .. rowSize .. bytes.Length - rowSize - 1 do
        printfn $"{BitConverter.ToString(bytes, i, rowSize)}-"
        iter <- i

    printfn $"{BitConverter.ToString(bytes, iter + rowSize)}\n"

let byteArray =
    [| 255uy; 255uy; 255uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy; 0uy
       0uy; 1uy; 0uy; 0uy; 0uy; 100uy; 167uy; 179uy; 182uy; 224uy
       13uy; 0uy; 202uy; 154uy; 59uy; 0uy; 0uy; 0uy; 0uy; 170uy
       170uy; 170uy; 170uy; 170uy; 170uy; 0uy; 0uy; 232uy; 137uy; 4uy
       35uy; 199uy; 138uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy; 255uy
       255uy; 127uy |]

printfn "This example of the BitConverter.ToUInt64(byte [], int) \nmethod generates the following output. It converts elements \nof a byte array to ulong values.\n"

writeMultiLineByteArray byteArray 

print "index" "array elements" "ulong"
print "-----" "--------------" "------"

// Convert byte array elements to ulong values.
BAToUInt64 byteArray 3
BAToUInt64 byteArray 0
BAToUInt64 byteArray 21
BAToUInt64 byteArray 7
BAToUInt64 byteArray 29
BAToUInt64 byteArray 13
BAToUInt64 byteArray 35
BAToUInt64 byteArray 44
BAToUInt64 byteArray 43


// This example of the BitConverter.ToUInt64( byte[ ], int )
// method generates the following output. It converts elements
// of a byte array to ulong values.
//
// initial byte array
// ------------------
// FF-FF-FF-00-00-00-00-00-00-00-00-01-00-00-00-64-A7-B3-B6-E0-
// 0D-00-CA-9A-3B-00-00-00-00-AA-AA-AA-AA-AA-AA-00-00-E8-89-04-
// 23-C7-8A-FF-FF-FF-FF-FF-FF-FF-FF-7F
//
// index             array elements                   ulong
// -----             --------------                  ------
//     3    00-00-00-00-00-00-00-00                       0
//     0    FF-FF-FF-00-00-00-00-00                16777215
//    21    00-CA-9A-3B-00-00-00-00              1000000000
//     7    00-00-00-00-01-00-00-00              4294967296
//    29    AA-AA-AA-AA-AA-AA-00-00         187649984473770
//    13    00-00-64-A7-B3-B6-E0-0D     1000000000000000000
//    35    00-00-E8-89-04-23-C7-8A    10000000000000000000
//    44    FF-FF-FF-FF-FF-FF-FF-7F     9223372036854775807
//    43    FF-FF-FF-FF-FF-FF-FF-FF    18446744073709551615
' Example of the BitConverter.ToUInt64 method.
Module BytesToUInt64Demo

    Const formatter As String = "{0,5}{1,27}{2,24}"
 
    ' Convert eight Byte array elements to a UInt64 and display it.
    Sub BAToUInt64( bytes( ) As Byte, index As Integer )

        Dim value As UInt64 = BitConverter.ToUInt64( bytes, index )

        Console.WriteLine( formatter, index, _
            BitConverter.ToString( bytes, index, 8 ), value )
    End Sub 

    ' Display a Byte array, using multiple lines if necessary.
    Sub WriteMultiLineByteArray( bytes( ) As Byte )
       
        Const rowSize As Integer = 20 
        Dim iter As Integer

        Console.WriteLine( "initial Byte array" )
        Console.WriteLine( "------------------" )

        For iter = 0 To bytes.Length - rowSize - 1 Step rowSize
            Console.Write( _
                BitConverter.ToString( bytes, iter, rowSize ) )
            Console.WriteLine( "-" )
        Next iter

        Console.WriteLine( BitConverter.ToString( bytes, iter ) )
        Console.WriteLine( )
    End Sub

    Sub Main( )
        Dim byteArray as Byte( ) = { _
            255, 255, 255,   0,   0,   0,   0,   0,   0,   0, _
              0,   1,   0,   0,   0, 100, 167, 179, 182, 224, _
             13,   0, 202, 154,  59,   0,   0,   0,   0, 170, _
            170, 170, 170, 170, 170,   0,   0, 232, 137,   4, _
             35, 199, 138, 255, 255, 255, 255, 255, 255, 255, _
            255, 127 }

        Console.WriteLine( _
            "This example of the BitConverter.ToUInt64( Byte( ), " & _
            "Integer ) " & vbCrLf & "method generates the " & _
            "following output. It converts elements " & vbCrLf & _
            "of a Byte array to UInt64 values." & vbCrLf )

        WriteMultiLineByteArray( byteArray )

        Console.WriteLine( formatter, "index", "array elements", _
            "UInt64" )
        Console.WriteLine( formatter, "-----", "--------------", _
            "------" )
          
        ' Convert Byte array elements to UInt64 values.
        BAToUInt64( byteArray, 3 )
        BAToUInt64( byteArray, 0 )
        BAToUInt64( byteArray, 21 )
        BAToUInt64( byteArray, 7 )
        BAToUInt64( byteArray, 29 )
        BAToUInt64( byteArray, 13 )
        BAToUInt64( byteArray, 35 )
        BAToUInt64( byteArray, 44 )
        BAToUInt64( byteArray, 43 )
    End Sub 
End Module

' This example of the BitConverter.ToUInt64( Byte( ), Integer )
' method generates the following output. It converts elements
' of a Byte array to UInt64 values.
' 
' initial Byte array
' ------------------
' FF-FF-FF-00-00-00-00-00-00-00-00-01-00-00-00-64-A7-B3-B6-E0-
' 0D-00-CA-9A-3B-00-00-00-00-AA-AA-AA-AA-AA-AA-00-00-E8-89-04-
' 23-C7-8A-FF-FF-FF-FF-FF-FF-FF-FF-7F
' 
' index             array elements                  UInt64
' -----             --------------                  ------
'     3    00-00-00-00-00-00-00-00                       0
'     0    FF-FF-FF-00-00-00-00-00                16777215
'    21    00-CA-9A-3B-00-00-00-00              1000000000
'     7    00-00-00-00-01-00-00-00              4294967296
'    29    AA-AA-AA-AA-AA-AA-00-00         187649984473770
'    13    00-00-64-A7-B3-B6-E0-0D     1000000000000000000
'    35    00-00-E8-89-04-23-C7-8A    10000000000000000000
'    44    FF-FF-FF-FF-FF-FF-FF-7F     9223372036854775807
'    43    FF-FF-FF-FF-FF-FF-FF-FF    18446744073709551615

Commenti

Il ToUInt64 metodo converte i byte dall'indice startIndex a startIndex + 7 in un UInt64 valore. L'ordine dei byte nella matrice deve riflettere l'endianità dell'architettura del sistema computer. Per altre informazioni, vedere la sezione Osservazioni dell'argomento BitConverter della classe.

Vedi anche

Si applica a

ToUInt64(ReadOnlySpan<Byte>)

Importante

Questa API non è conforme a CLS.

Converte i byte in un valore long senza segno.

public:
 static System::UInt64 ToUInt64(ReadOnlySpan<System::Byte> value);
[System.CLSCompliant(false)]
public static ulong ToUInt64 (ReadOnlySpan<byte> value);
[<System.CLSCompliant(false)>]
static member ToUInt64 : ReadOnlySpan<byte> -> uint64
Public Shared Function ToUInt64 (value As ReadOnlySpan(Of Byte)) As ULong

Parametri

value
ReadOnlySpan<Byte>

Intervallo di sola lettura contenente i byte da convertire.

Restituisce

UInt64

Intero senza segno a 64 bit che rappresenta i byte convertiti.

Attributi

Eccezioni

La lunghezza di value è minore di 8.

Si applica a