BitConverter BitConverter BitConverter BitConverter Class

Definizione

Converte tipi di dati di base in una matrice di byte e una matrice di byte in tipi di dati di base.Converts base data types to an array of bytes, and an array of bytes to base data types.

public ref class BitConverter abstract sealed
public static class BitConverter
type BitConverter = class
Public Class BitConverter
Ereditarietà
BitConverterBitConverterBitConverterBitConverter

Esempi

Esempio di codice seguente viene illustrato l'utilizzo delle diverse BitConverter metodi della classe.The following code example illustrates the use of several BitConverter class methods.

// Example of BitConverter class methods.
using namespace System;
int main()
{
   String^ formatter = "{0,25}{1,30}";
   double aDoubl = 0.1111111111111111111;
   float aSingl = 0.1111111111111111111F;
   __int64 aLong = 1111111111111111111;
   int anInt = 1111111111;
   short aShort = 11111;
   __wchar_t aChar = L'*';
   bool aBool = true;
   Console::WriteLine( "This example of methods of the BitConverter class"
   "\ngenerates the following output.\n" );
   Console::WriteLine( formatter, "argument", "byte array" );
   Console::WriteLine( formatter, "--------", "----------" );
   
   // Convert values to Byte arrays and display them.
   Console::WriteLine( formatter, aDoubl, BitConverter::ToString( BitConverter::GetBytes( aDoubl ) ) );
   Console::WriteLine( formatter, aSingl, BitConverter::ToString( BitConverter::GetBytes( aSingl ) ) );
   Console::WriteLine( formatter, aLong, BitConverter::ToString( BitConverter::GetBytes( aLong ) ) );
   Console::WriteLine( formatter, anInt, BitConverter::ToString( BitConverter::GetBytes( anInt ) ) );
   Console::WriteLine( formatter, aShort, BitConverter::ToString( BitConverter::GetBytes( aShort ) ) );
   Console::WriteLine( formatter, aChar, BitConverter::ToString( BitConverter::GetBytes( aChar ) ) );
   Console::WriteLine( formatter, aBool, BitConverter::ToString( BitConverter::GetBytes( aBool ) ) );
}

/*
This example of methods of the BitConverter class
generates the following output.

                 argument                    byte array
                 --------                    ----------
        0.111111111111111       1C-C7-71-1C-C7-71-BC-3F
                0.1111111                   39-8E-E3-3D
      1111111111111111111       C7-71-C4-2B-AB-75-6B-0F
               1111111111                   C7-35-3A-42
                    11111                         67-2B
                        *                         2A-00
                     True                            01
*/
// Example of BitConverter class methods.
using System;

class BitConverterDemo
{
    public static void Main( )
    {
        const string formatter = "{0,25}{1,30}";
 
        double  aDoubl  = 0.1111111111111111111;
        float   aSingl  = 0.1111111111111111111F;
        long    aLong   = 1111111111111111111;
        int     anInt   = 1111111111;
        short   aShort  = 11111;
        char    aChar   = '*';
        bool    aBool   = true;

        Console.WriteLine( 
            "This example of methods of the BitConverter class" +
            "\ngenerates the following output.\n" );
        Console.WriteLine( formatter, "argument", "byte array" );
        Console.WriteLine( formatter, "--------", "----------" );

        // Convert values to Byte arrays and display them.
        Console.WriteLine( formatter, aDoubl, 
            BitConverter.ToString( BitConverter.GetBytes( aDoubl ) ) );
        Console.WriteLine( formatter, aSingl, 
            BitConverter.ToString( BitConverter.GetBytes( aSingl ) ) );
        Console.WriteLine( formatter, aLong, 
            BitConverter.ToString( BitConverter.GetBytes( aLong ) ) );
        Console.WriteLine( formatter, anInt, 
            BitConverter.ToString( BitConverter.GetBytes( anInt ) ) );
        Console.WriteLine( formatter, aShort, 
            BitConverter.ToString( BitConverter.GetBytes( aShort ) ) );
        Console.WriteLine( formatter, aChar, 
            BitConverter.ToString( BitConverter.GetBytes( aChar ) ) );
        Console.WriteLine( formatter, aBool, 
            BitConverter.ToString( BitConverter.GetBytes( aBool ) ) );
    }
}

/*
This example of methods of the BitConverter class
generates the following output.

                 argument                    byte array
                 --------                    ----------
        0.111111111111111       1C-C7-71-1C-C7-71-BC-3F
                0.1111111                   39-8E-E3-3D
      1111111111111111111       C7-71-C4-2B-AB-75-6B-0F
               1111111111                   C7-35-3A-42
                    11111                         67-2B
                        *                         2A-00
                     True                            01
*/
' Example of BitConverter class methods.
Module BitConverterDemo

    Sub Main( )

        Const formatter As String = "{0,25}{1,30}"
 
        Dim aDoubl      As Double   = 0.1111111111111111111
        Dim aSingl      As Single   = 0.1111111111111111111
        Dim aLong       As Long     = 1111111111111111111
        Dim anInt       As Integer  = 1111111111
        Dim aShort      As Short    = 11111
        Dim aChar       As Char     = "*"c
        Dim aBool       As Boolean  = True

        Console.WriteLine( _
            "This example of methods of the BitConverter class" & _
            vbCrLf & "generates the following output." & vbCrLf )
        Console.WriteLine( formatter, "argument", "Byte array" )
        Console.WriteLine( formatter, "--------", "----------" )

        ' Convert values to Byte arrays and display them.
        Console.WriteLine( formatter, aDoubl, _
            BitConverter.ToString( BitConverter.GetBytes( aDoubl ) ) )
        Console.WriteLine( formatter, aSingl, _
            BitConverter.ToString( BitConverter.GetBytes( aSingl ) ) )
        Console.WriteLine( formatter, aLong, _
            BitConverter.ToString( BitConverter.GetBytes( aLong ) ) )
        Console.WriteLine( formatter, anInt, _
            BitConverter.ToString( BitConverter.GetBytes( anInt ) ) )
        Console.WriteLine( formatter, aShort, _
            BitConverter.ToString( BitConverter.GetBytes( aShort ) ) )
        Console.WriteLine( formatter, aChar, _
            BitConverter.ToString( BitConverter.GetBytes( aChar ) ) )
        Console.WriteLine( formatter, aBool, _
            BitConverter.ToString( BitConverter.GetBytes( aBool ) ) )
    End Sub
End Module

' This example of methods of the BitConverter class
' generates the following output.
' 
'                  argument                    Byte array
'                  --------                    ----------
'         0.111111111111111       1C-C7-71-1C-C7-71-BC-3F
'                 0.1111111                   39-8E-E3-3D
'       1111111111111111111       C7-71-C4-2B-AB-75-6B-0F
'                1111111111                   C7-35-3A-42
'                     11111                         67-2B
'                         *                         2A-00
'                      True                            01

Commenti

Il BitConverter classe consente di modificare i tipi di valore nella relativa forma fondamentale, come una serie di byte.The BitConverter class helps manipulate value types in their fundamental form, as a series of bytes. Un byte è definito come un intero senza segno a 8 bit.A byte is defined as an 8-bit unsigned integer. Il BitConverter classe include metodi statici per ogni tipo primitivo di conversione da e verso una matrice di byte, come illustrato nella tabella seguente.The BitConverter class includes static methods to convert each of the primitive types to and from an array of bytes, as the following table illustrates.

TipoType Per la conversione di byteTo byte conversion Conversione di byteFrom byte conversion
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

-oppure--or-

DoubleToInt64Bits(Double)
ToDouble

-oppure--or-

Int64BitsToDouble
Int16 GetBytes(Int16) ToInt16
Int32 GetBytes(Int32) ToInt32
Int64 GetBytes(Int64) ToInt64
Single GetBytes(Single) ToSingle
UInt16 GetBytes(UInt16) ToUInt16
UInt32 GetBytes(UInt32) ToUInt32
UInt64 GetBytes(UInt64) ToUInt64

Se si usa BitConverter metodi per eseguire il round trip dei dati, assicurarsi che il GetBytes overload e il To tipo metodo specificano lo stesso tipo.If you use BitConverter methods to round-trip data, make sure that the GetBytes overload and the ToType method specify the same type. Come illustrato nell'esempio seguente, il ripristino di una matrice che rappresenta un intero con segno chiamando il ToUInt32 metodo può comportare un valore che è diverso dall'originale.As the following example illustrates, restoring an array that represents a signed integer by calling the ToUInt32 method can result in a value that is different from the original. Per altre informazioni, vedere l'intervento elaborano decimale Non firmato e bit per bit di valori nel Blog del Team BCL.For more information, see the entry Working with Signed Non-Decimal and Bitwise Values in the BCL Team Blog.

using System;

public class Example
{
   public static void Main()
   {
      int value = -16;
      Byte[] bytes = BitConverter.GetBytes(value); 
      
      // Convert bytes back to Int32.
      int intValue = BitConverter.ToInt32(bytes, 0);
      Console.WriteLine("{0} = {1}: {2}", 
                        value, intValue, 
                        value.Equals(intValue) ? "Round-trips" : "Does not round-trip");
      // Convert bytes to UInt32.
      uint uintValue = BitConverter.ToUInt32(bytes, 0);
      Console.WriteLine("{0} = {1}: {2}", value, uintValue, 
                        value.Equals(uintValue) ? "Round-trips" : "Does not round-trip");
   }
}
// The example displays the following output:
//       -16 = -16: Round-trips
//       -16 = 4294967280: Does not round-trip
Module Example
   Public Sub Main()
      Dim value As Integer = -16
      Dim bytes() As Byte = BitConverter.GetBytes(value) 
      
      ' Convert bytes back to Int32.
      Dim intValue As Integer = BitConverter.ToInt32(bytes, 0)
      Console.WriteLine("{0} = {1}: {2}", 
                        value, intValue, 
                        If(value.Equals(intValue), "Round-trips", "Does not round-trip"))
      ' Convert bytes to UInt32.
      Dim uintValue As UInteger = BitConverter.ToUInt32(bytes, 0)
      Console.WriteLine("{0} = {1}: {2}", value, uintValue, 
                        If(value.Equals(uintValue), "Round-trips", "Does not round-trip"))
   End Sub
End Module
' The example displays the following output:
'       -16 = -16: Round-trips
'       -16 = 4294967280: Does not round-trip

L'ordine dei byte nella matrice restituita dal GetBytes overload del metodo (così come dell'ordine di bit nel valore integer restituito dal DoubleToInt64Bits metodo e l'ordine delle stringhe esadecimali restituito dal ToString(Byte[]) (metodo)) dipende dal fatto che il architettura del computer è little-endian o big-endian.The order of bytes in the array returned by the GetBytes method overloads (as well as the order of bits in the integer returned by the DoubleToInt64Bits method and the order of hexadecimal strings returned by the ToString(Byte[]) method) depends on whether the computer architecture is little-endian or big-endian. Allo stesso modo, l'ordine dei byte nella matrice e restituito dal To IntegerValue metodi e le ToChar metodo dipende dal fatto che l'architettura del computer è little-endian o big-endian.Similarly, the order of bytes in the array and returned by the ToIntegerValue methods and the ToChar method depends on whether the computer architecture is little-endian or big-endian. L'ordine dei byte di architettura è indicato dal IsLittleEndian proprietà, che restituisce true nei sistemi little-endian e false nei sistemi big-endian.The endianness of an architecture is indicated by the IsLittleEndian property, which returns true on little-endian systems and false on big-endian systems. Nei sistemi little-endian, byte meno significativi precedono byte di ordine superiore.On little-endian systems, lower-order bytes precede higher-order bytes. Nel sistema big-endian, byte di ordine superiore precedono byte meno significativi.On big-endian system, higher-order bytes precede lower-order bytes. La tabella seguente illustra la differenza tra le matrici di byte che derivano da passando l'intero 1.234.567.890 (0x499602D2) per il GetBytes(Int32) (metodo).The following table illustrates the difference in the byte arrays that result from passing the integer 1,234,567,890 (0x499602D2) to the GetBytes(Int32) method. I byte sono elencati in ordine da un byte in corrispondenza dell'indice 0 al byte in corrispondenza dell'indice 3.The bytes are listed in order from the byte at index 0 to the byte at index 3.

Little-endianLittle-endian D2-02-96-49D2-02-96-49
Big-endianBig-endian 49-96-02-D249-96-02-D2

Poiché il valore restituito di alcuni metodi dipende dall'architettura del sistema, prestare attenzione durante la trasmissione di dati byte oltre i limiti della macchina:Because the return value of some methods depends on system architecture, be careful when transmitting byte data beyond machine boundaries:

  • Se tutti i sistemi di inviare e ricevere dati sono garantiti l'ordine dei byte stessa, è richiesta alcuna operazione per i dati.If all systems sending and receiving data are guaranteed to have the same endianness, nothing has be done to the data.

  • Se i sistemi inviano e ricevono dati possono avere ordine dei byte diverso, sempre trasmettono i dati in un ordine particolare.If systems sending and receiving data can have different endianness, always transmit data in a particular order. Ciò significa che l'ordine dei byte nella matrice potrebbe essere necessario invertire prima di inviarli o dopo averli ricevuti.This means that the order of bytes in the array may have to be reversed either before sending them or after receiving them. Una convenzione comune consiste nel trasmettere i dati in ordine di byte di rete (nell'ordine big endian).A common convention is to transmit data in network byte order (big-endian order). Nell'esempio seguente fornisce un'implementazione per l'invio di un valore intero nell'ordine dei byte della rete.The following example provides an implementation for sending an integer value in network byte order.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          int value = 12345678;
          byte[] bytes = BitConverter.GetBytes(value);
          Console.WriteLine(BitConverter.ToString(bytes));
          
          if (BitConverter.IsLittleEndian)
             Array.Reverse(bytes); 
    
          Console.WriteLine(BitConverter.ToString(bytes));
          // Call method to send byte stream across machine boundaries.
          
          // Receive byte stream from beyond machine boundaries.
          Console.WriteLine(BitConverter.ToString(bytes));
          if (BitConverter.IsLittleEndian)
             Array.Reverse(bytes);
    
          Console.WriteLine(BitConverter.ToString(bytes));
          int result = BitConverter.ToInt32(bytes, 0);
          Console.WriteLine("Original value: {0}", value);
          Console.WriteLine("Returned value: {0}", result);
       }
    }
    // The example displays the following output on a little-endian system:
    //       4E-61-BC-00
    //       00-BC-61-4E
    //       00-BC-61-4E
    //       4E-61-BC-00
    //       Original value: 12345678
    //       Returned value: 12345678
    
    Module Example
       Public Sub Main()
          Dim value As Integer = 12345678
          Dim bytes() As Byte = BitConverter.GetBytes(value)
          Console.WriteLine(BitConverter.ToString(bytes))
          
          If BitConverter.IsLittleEndian Then
             Array.Reverse(bytes) 
          End If
          Console.WriteLine(BitConverter.ToString(bytes))
          ' Call method to send byte stream across machine boundaries.
          
          ' Receive byte stream from beyond machine boundaries.
          Console.WriteLine(BitConverter.ToString(bytes))
          If BitConverter.IsLittleEndian Then     
             Array.Reverse(bytes)
          End If   
          Console.WriteLine(BitConverter.ToString(bytes))
          Dim result As Integer = BitConverter.ToInt32(bytes, 0)
          Console.WriteLine("Original value: {0}", value)
          Console.WriteLine("Returned value: {0}", result)
       End Sub
    End Module
    ' The example displays the following output on a little-endian system:
    '       4E-61-BC-00
    '       00-BC-61-4E
    '       00-BC-61-4E
    '       4E-61-BC-00
    '       Original value: 12345678
    '       Returned value: 12345678
    
  • Sistemi che inviano e ricevono dati possono avere l'ordine dei byte diverso e i dati da trasmettere è costituito da interi con segno, chiamare il IPAddress.HostToNetworkOrder metodo per convertire i dati in ordine dei byte della rete e il IPAddress.NetworkToHostOrder per convertirlo in ordine richiesto (metodo) dal destinatario.If systems sending and receiving data can have different endianness and the data to be transmitted consists of signed integers, call the IPAddress.HostToNetworkOrder method to convert the data to network byte order and the IPAddress.NetworkToHostOrder method to convert it to the order required by the recipient.

Campi

IsLittleEndian IsLittleEndian IsLittleEndian IsLittleEndian

Indica l'ordine dei byte ("architettura endian") in cui vengono memorizzati i dati in questa architettura di computer.Indicates the byte order ("endianness") in which data is stored in this computer architecture.

Metodi

DoubleToInt64Bits(Double) DoubleToInt64Bits(Double) DoubleToInt64Bits(Double) DoubleToInt64Bits(Double)

Converte il numero a virgola mobile a precisione doppia specificato in un intero con segno a 64 bit.Converts the specified double-precision floating point number to a 64-bit signed integer.

GetBytes(Boolean) GetBytes(Boolean) GetBytes(Boolean) GetBytes(Boolean)

Restituisce il valore booleano specificato come matrice di byte.Returns the specified Boolean value as a byte array.

GetBytes(Char) GetBytes(Char) GetBytes(Char) GetBytes(Char)

Restituisce il valore del carattere Unicode specificato come matrice di byte.Returns the specified Unicode character value as an array of bytes.

GetBytes(Double) GetBytes(Double) GetBytes(Double) GetBytes(Double)

Restituisce il valore in virgola mobile a precisione doppia specificato come matrice di byte.Returns the specified double-precision floating point value as an array of bytes.

GetBytes(Int16) GetBytes(Int16) GetBytes(Int16) GetBytes(Int16)

Restituisce il valore intero con segno a 16 bit specificato come matrice di byte.Returns the specified 16-bit signed integer value as an array of bytes.

GetBytes(Int32) GetBytes(Int32) GetBytes(Int32) GetBytes(Int32)

Restituisce il valore intero con segno a 32 bit specificato come matrice di byte.Returns the specified 32-bit signed integer value as an array of bytes.

GetBytes(Int64) GetBytes(Int64) GetBytes(Int64) GetBytes(Int64)

Restituisce il valore intero con segno a 64 bit specificato come matrice di byte.Returns the specified 64-bit signed integer value as an array of bytes.

GetBytes(Single) GetBytes(Single) GetBytes(Single) GetBytes(Single)

Restituisce il valore in virgola mobile a precisione singola specificato come matrice di byte.Returns the specified single-precision floating point value as an array of bytes.

GetBytes(UInt16) GetBytes(UInt16) GetBytes(UInt16) GetBytes(UInt16)

Restituisce il valore intero senza segno a 16 bit specificato come matrice di byte.Returns the specified 16-bit unsigned integer value as an array of bytes.

GetBytes(UInt32) GetBytes(UInt32) GetBytes(UInt32) GetBytes(UInt32)

Restituisce il valore dell'intero senza segno a 32 bit specificato come matrice di byte.Returns the specified 32-bit unsigned integer value as an array of bytes.

GetBytes(UInt64) GetBytes(UInt64) GetBytes(UInt64) GetBytes(UInt64)

Restituisce il valore dell'intero senza segno a 64 bit specificato come matrice di byte.Returns the specified 64-bit unsigned integer value as an array of bytes.

Int32BitsToSingle(Int32) Int32BitsToSingle(Int32) Int32BitsToSingle(Int32) Int32BitsToSingle(Int32)
Int64BitsToDouble(Int64) Int64BitsToDouble(Int64) Int64BitsToDouble(Int64) Int64BitsToDouble(Int64)

Converte l'intero con segno a 64 bit specificato in un numero a virgola mobile a precisione doppia.Converts the specified 64-bit signed integer to a double-precision floating point number.

SingleToInt32Bits(Single) SingleToInt32Bits(Single) SingleToInt32Bits(Single) SingleToInt32Bits(Single)
ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>)
ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32)

Restituisce un valore booleano convertito da un byte in una posizione specificata in una matrice di byte.Returns a Boolean value converted from the byte at a specified position in a byte array.

ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>)
ToChar(Byte[], Int32) ToChar(Byte[], Int32) ToChar(Byte[], Int32) ToChar(Byte[], Int32)

Restituisce un carattere Unicode convertito da due byte nella posizione specificata in una matrice di byte.Returns a Unicode character converted from two bytes at a specified position in a byte array.

ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>)
ToDouble(Byte[], Int32) ToDouble(Byte[], Int32) ToDouble(Byte[], Int32) ToDouble(Byte[], Int32)

Restituisce un numero a virgola mobile a precisione doppia convertito da otto byte nella posizione specificata in una matrice di byte.Returns a double-precision floating point number converted from eight bytes at a specified position in a byte array.

ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>)
ToInt16(Byte[], Int32) ToInt16(Byte[], Int32) ToInt16(Byte[], Int32) ToInt16(Byte[], Int32)

Restituisce un intero con segno a 16 bit convertito da due byte nella posizione specificata in una matrice di byte.Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.

ToInt32(Byte[], Int32) ToInt32(Byte[], Int32) ToInt32(Byte[], Int32) ToInt32(Byte[], Int32)

Restituisce un intero con segno a 32 bit convertito da quattro byte nella posizione specificata in una matrice di byte.Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.

ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>)
ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>)
ToInt64(Byte[], Int32) ToInt64(Byte[], Int32) ToInt64(Byte[], Int32) ToInt64(Byte[], Int32)

Restituisce un intero con segno a 64 bit convertito da otto byte nella posizione specificata in una matrice di byte.Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.

ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>)
ToSingle(Byte[], Int32) ToSingle(Byte[], Int32) ToSingle(Byte[], Int32) ToSingle(Byte[], Int32)

Restituisce un numero a virgola mobile a precisione singola convertito da quattro byte nella posizione specificata in una matrice di byte.Returns a single-precision floating point number converted from four bytes at a specified position in a byte array.

ToString(Byte[]) ToString(Byte[]) ToString(Byte[]) ToString(Byte[])

Converte il valore numerico di ogni elemento di una matrice di byte specificata nella relativa rappresentazione di stringa esadecimale equivalente.Converts the numeric value of each element of a specified array of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32) ToString(Byte[], Int32) ToString(Byte[], Int32) ToString(Byte[], Int32)

Converte il valore numerico di ogni elemento di una sottomatrice specificata di byte nella relativa rappresentazione di stringa esadecimale equivalente.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32)

Converte il valore numerico di ogni elemento di una sottomatrice specificata di byte nella relativa rappresentazione di stringa esadecimale equivalente.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>)
ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32)

Restituisce un intero senza segno a 16 bit convertito da due byte nella posizione specificata in una matrice di byte.Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>)
ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32)

Restituisce un intero senza segno a 32 bit convertito da quattro byte nella posizione specificata in una matrice di byte.Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.

ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32)

Restituisce un intero senza segno a 64 bit convertito da otto byte nella posizione specificata in una matrice di byte.Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.

ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>)
TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean)
TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char)
TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double)
TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16)
TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32)
TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64)
TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single)
TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16)
TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32)
TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64)

Si applica a

Vedi anche