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

Nell'esempio di codice riportato di seguito viene illustrato l' BitConverter utilizzo di diversi metodi di 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

La BitConverter classe consente di modificare i tipi di valore nel formato fondamentale, come una serie di byte.The BitConverter class helps manipulate value types in their fundamental form, as a series of bytes. Un byte viene definito come Unsigned Integer a 8 bit.A byte is defined as an 8-bit unsigned integer. La BitConverter classe include metodi statici per convertire ognuno dei tipi primitivi in e da 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 Conversione in byteTo byte conversion Da conversione in 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 usano BitConverter i metodi per eseguire il round trip dei dati, assicurarsi GetBytes che l'overload Toe il metodo del tipo specifichino 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 ToUInt32 il metodo può generare un valore 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 ulteriori informazioni, vedere l'articolo relativo all' utilizzo di valori con segno non decimale e bit per bit 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 dagli overload GetBytes del metodo (così come l'ordine dei bit nell'integer restituito DoubleToInt64Bits dal metodo e l'ordine delle stringhe ToString(Byte[]) esadecimali restituite dal metodo) dipende dal fatto che l'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. Analogamente, l'ordine dei byte nella matrice e restituito dai Tometodi IntegerValue e ToChar dal metodo varia a seconda che l'architettura del computer sia 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'oggetto dell'architettura è indicato dalla IsLittleEndian proprietà, che viene restituita 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, i byte di ordine inferiore precedono i byte di ordine superiore.On little-endian systems, lower-order bytes precede higher-order bytes. Nel sistema big-endian, i byte di ordine superiore precedono i byte di ordine inferiore.On big-endian system, higher-order bytes precede lower-order bytes. Nella tabella seguente viene illustrata la differenza tra le matrici di byte risultante dal passaggio dell'intero 1.234.567.890 (0x499602D2) al 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 vengono elencati in ordine dal 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 di sistema, prestare attenzione quando si trasmettono dati di byte oltre i limiti del computer:Because the return value of some methods depends on system architecture, be careful when transmitting byte data beyond machine boundaries:

  • Se tutti i sistemi che inviano e ricevono dati hanno la stessa caratteristica, non verrà eseguita alcuna operazione sui 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 che inviano e ricevono dati possono avere diversi tipi di dati, trasmettere sempre i dati in un ordine specifico.If systems sending and receiving data can have different endianness, always transmit data in a particular order. Ciò significa che è possibile che l'ordine dei byte nella matrice sia invertito prima di inviarli o dopo riceverli.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 byte di rete (ordine big endian).A common convention is to transmit data in network byte order (big-endian order). Nell'esempio seguente viene fornita un'implementazione per l'invio di un valore integer nell'ordine dei byte di 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
    
  • Se i sistemi che inviano e ricevono dati possono avere un'altra caratteristica di visualizzazione e i dati da trasmettere sono costituiti da interi con segno, chiamare il IPAddress.HostToNetworkOrder metodo per convertire i dati in ordine byte di rete e il IPAddress.NetworkToHostOrder metodo per convertirli nell'ordine richiesto. 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 in virgola mobile e 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 e 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 dell'integer 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 e 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 dell'integer 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 in virgola mobile e 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 in virgola mobile e 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 in virgola mobile e 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 specificata di byte 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