BitConverter.ToUInt64 Metod

Definition

Namnområde:
System
Sammansättningar:
mscorlib.dll, System.Runtime.Extensions.dll
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Runtime.Extensions.dll
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll

Överlagringar

Name Description
ToUInt64(Byte[], Int32)

Returnerar ett 64-bitars osignerat heltal konverterat från åtta byte vid en angiven position i en bytematris.
ToUInt64(ReadOnlySpan<Byte>)

Konverterar byte till en lång osignerad.

ToUInt64(Byte[], Int32)

Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs

Viktigt!

Detta API uppfyller inte CLS.

Returnerar ett 64-bitars osignerat heltal konverterat från åtta byte vid en angiven position i en bytematris.

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

Parametrar

value
Byte[]

En matris med byte som innehåller de åtta byte som ska konverteras.

startIndex
Int32

Startpositionen inom value.

Returer

UInt64

Ett 64-bitars osignerat heltal som bildas av de åtta byte som börjar på startIndex.

Attribut
CLSCompliantAttribute

Undantag

ArgumentException

startIndex är större än eller lika med längden value på minus 7 och är mindre än eller lika med längden value på minus 1.

ArgumentNullException

value är null.

ArgumentOutOfRangeException

startIndex är mindre än noll eller större än längden value på minus 1.

Exempel

I följande kodexempel konverteras element i Byte matriser till UInt64 värden med ToUInt64 -metoden.

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

Kommentarer

Metoden ToUInt64 konverterar byte från index startIndex till startIndex + 7 till ett UInt64 värde. Ordningen på byte i matrisen måste återspegla endianiteten i datorsystemets arkitektur. Mer information finns i avsnittet Kommentarer i klassavsnittet BitConverter .

Se även

Gäller för

ToUInt64(ReadOnlySpan<Byte>)

Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs
Källa:
BitConverter.cs

Viktigt!

Detta API uppfyller inte CLS.

Konverterar byte till en lång osignerad.

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

Parametrar

value
ReadOnlySpan<Byte>

Ett skrivskyddat intervall som innehåller de byte som ska konverteras.

Returer

UInt64

Ett 64-bitars osignerat heltal som representerar de konverterade byteen.

Attribut
CLSCompliantAttribute

Undantag

ArgumentOutOfRangeException

Längden value på är mindre än 8.

Gäller för