BitConverter Clase

Definición

Convierte tipos de datos base en una matriz de bytes, y una matriz de bytes en tipos de datos 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
Herencia
BitConverter

Ejemplos

En el ejemplo de código siguiente se muestra el uso de varios métodos de clase BitConverter.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

Comentarios

La clase BitConverter ayuda a manipular tipos de valor en su forma fundamental, como una serie de bytes.The BitConverter class helps manipulate value types in their fundamental form, as a series of bytes. Un byte se define como un entero de 8 bits sin signo.A byte is defined as an 8-bit unsigned integer. La clase BitConverter incluye métodos estáticos para convertir cada uno de los tipos primitivos a y desde una matriz de bytes, como se muestra en la tabla siguiente.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 A conversión de bytesTo byte conversion Desde conversión de bytesFrom byte conversion
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

o bien-or-

DoubleToInt64Bits(Double)
ToDouble

O bien-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

Si usa métodos BitConverter para los datos de ida y vuelta, asegúrese de que la sobrecarga de GetBytes y el método detipo To especifiquen el mismo tipo.If you use BitConverter methods to round-trip data, make sure that the GetBytes overload and the ToType method specify the same type. Como se muestra en el ejemplo siguiente, la restauración de una matriz que representa un entero con signo llamando al método ToUInt32 puede dar lugar a un valor diferente del original.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. Para obtener más información, vea la entrada trabajar con valores no decimales y no decimales firmados en el blog del equipo de 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

El orden de los bytes de la matriz devuelto por las sobrecargas del método GetBytes (así como el orden de los bits en el entero devuelto por el método DoubleToInt64Bits y el orden de las cadenas hexadecimales devueltas por el método ToString(Byte[])) depende de si la arquitectura del equipo es 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. Del mismo modo, el orden de los bytes de la matriz y devueltos por @no__t los métodosIntegerValue -0 y el método ToChar depende de si la arquitectura del equipo es 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. La modos endian de una arquitectura se indica mediante la propiedad IsLittleEndian, que devuelve true en los sistemas Little-endian y false en los sistemas 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. En los sistemas Little-endian, los bytes de orden inferior preceden a los bytes de orden superior.On little-endian systems, lower-order bytes precede higher-order bytes. En el sistema big-endian, los bytes de orden superior preceden a los bytes de orden inferior.On big-endian system, higher-order bytes precede lower-order bytes. En la tabla siguiente se muestra la diferencia en las matrices de bytes que resultan de pasar el entero 1.234.567.890 (0x499602D2) al método GetBytes(Int32).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. Los bytes se enumeran en orden desde el byte 0 hasta el byte del índice 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

Dado que el valor devuelto de algunos métodos depende de la arquitectura del sistema, tenga cuidado al transmitir datos de bytes más allá de los límites del equipo:Because the return value of some methods depends on system architecture, be careful when transmitting byte data beyond machine boundaries:

  • Si se garantiza que todos los sistemas que envían y reciben datos tienen el mismo modos endian, no se hace nada en los datos.If all systems sending and receiving data are guaranteed to have the same endianness, nothing has be done to the data.

  • Si los sistemas que envían y reciben datos pueden tener modos endian diferentes, transmite siempre los datos en un orden determinado.If systems sending and receiving data can have different endianness, always transmit data in a particular order. Esto significa que el orden de los bytes de la matriz puede tener que invertirse antes de enviarlos o después de recibirlos.This means that the order of bytes in the array may have to be reversed either before sending them or after receiving them. Una Convención común es transmitir datos en el orden de bytes de la red (orden big-endian).A common convention is to transmit data in network byte order (big-endian order). En el ejemplo siguiente se proporciona una implementación para enviar un valor entero en el orden de bytes de la red.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
    
  • Si los sistemas que envían y reciben datos pueden tener diferentes modos endian y los datos que se van a transmitir se componen de enteros con signo, llame al método IPAddress.HostToNetworkOrder para convertir los datos al orden de bytes de la red y al método IPAddress.NetworkToHostOrder para convertirlos al orden requerido por el beneficia.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.

Campos

IsLittleEndian

Indica el orden de bytes ("modos endian") en los datos que se almacenan en la arquitectura de este equipo.Indicates the byte order ("endianness") in which data is stored in this computer architecture.

Métodos

DoubleToInt64Bits(Double)

Convierte el número de punto flotante de precisión doble especificado en un entero de 64 bits con signo.Converts the specified double-precision floating point number to a 64-bit signed integer.

GetBytes(Boolean)

Devuelve el valor booleano especificado como una matriz de bytes.Returns the specified Boolean value as a byte array.

GetBytes(Char)

Devuelve el valor de carácter Unicode especificado como una matriz de bytes.Returns the specified Unicode character value as an array of bytes.

GetBytes(Double)

Devuelve el valor de punto flotante de doble precisión especificado como una matriz de bytes.Returns the specified double-precision floating point value as an array of bytes.

GetBytes(Int16)

Devuelve el valor entero con signo de 16 bytes especificado como una matriz de bytes.Returns the specified 16-bit signed integer value as an array of bytes.

GetBytes(Int32)

Devuelve el valor del entero de 32 bits con signo especificado como una matriz de bytes.Returns the specified 32-bit signed integer value as an array of bytes.

GetBytes(Int64)

Devuelve el valor del entero de 64 bits con signo especificado como una matriz de bytes.Returns the specified 64-bit signed integer value as an array of bytes.

GetBytes(Single)

Devuelve el valor de punto flotante de precisión sencilla especificado como una matriz de bytes.Returns the specified single-precision floating point value as an array of bytes.

GetBytes(UInt16)

Devuelve el valor entero sin signo de 16 bits especificado como una matriz de bytes.Returns the specified 16-bit unsigned integer value as an array of bytes.

GetBytes(UInt32)

Devuelve el valor del entero sin signo de 32 bits especificado como una matriz de bytes.Returns the specified 32-bit unsigned integer value as an array of bytes.

GetBytes(UInt64)

Devuelve el valor del entero sin signo de 64 bits especificado como una matriz de bytes.Returns the specified 64-bit unsigned integer value as an array of bytes.

Int32BitsToSingle(Int32)

Reinterpreta el entero de 32 bits especificado como un valor de punto flotante de precisión sencilla.Reinterprets the specified 32-bit integer as a single-precision floating-point value.

Int64BitsToDouble(Int64)

Reinterpreta el entero de 64 bits con signo especificado en un número de punto flotante de precisión doble.Reinterprets the specified 64-bit signed integer to a double-precision floating point number.

SingleToInt32Bits(Single)

Convierte un valor de punto flotante de precisión sencilla en un entero.Converts a single-precision floating-point value into an integer.

ToBoolean(Byte[], Int32)

Devuelve un valor booleano convertido a partir del byte en la posición especificada de una matriz de bytes.Returns a Boolean value converted from the byte at a specified position in a byte array.

ToBoolean(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un valor booleano.Converts a read-only byte span to a Boolean value.

ToChar(Byte[], Int32)

Devuelve un carácter Unicode convertido a partir de dos bytes en la posición especificada de una matriz de bytes.Returns a Unicode character converted from two bytes at a specified position in a byte array.

ToChar(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un carácter.Converts a read-only byte span into a character.

ToDouble(Byte[], Int32)

Devuelve un número de punto flotante de precisión doble convertido a partir de ocho bytes en la posición especificada de una matriz de bytes.Returns a double-precision floating point number converted from eight bytes at a specified position in a byte array.

ToDouble(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un valor de punto flotante de precisión doble.Converts a read-only byte span into a double-precision floating-point value.

ToInt16(Byte[], Int32)

Devuelve un entero de 16 bits con signo convertido a partir de dos bytes en la posición especificada de una matriz de bytes.Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.

ToInt16(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 16 bits con signo.Converts a read-only byte span into a 16-bit signed integer.

ToInt32(Byte[], Int32)

Devuelve un entero de 32 bits con signo convertido a partir de cuatro bytes en la posición especificada de una matriz de bytes.Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.

ToInt32(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 32 bits con signo.Converts a read-only byte span into a 32-bit signed integer.

ToInt64(Byte[], Int32)

Devuelve un entero de 64 bits con signo convertido a partir de ocho bytes en la posición especificada de una matriz de bytes.Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.

ToInt64(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 64 bits con signo.Converts a read-only byte span into a 64-bit signed integer.

ToSingle(Byte[], Int32)

Devuelve un número de punto flotante de precisión sencilla convertido a partir de cuatro bytes en la posición especificada de una matriz de bytes.Returns a single-precision floating point number converted from four bytes at a specified position in a byte array.

ToSingle(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un valor de punto flotante de precisión doble.Converts a read-only byte span into a double-precision floating-point value.

ToString(Byte[])

Convierte el valor numérico de cada elemento de una matriz especificada de bytes en su representación de cadena hexadecimal equivalente.Converts the numeric value of each element of a specified array of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32)

Convierte el valor numérico de cada elemento de una submatriz especificada de bytes en su representación de cadena hexadecimal equivalente.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32, Int32)

Convierte el valor numérico de cada elemento de una submatriz especificada de bytes en su representación de cadena hexadecimal equivalente.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToUInt16(Byte[], Int32)

Devuelve un entero de 16 bits sin signo convertido a partir de dos bytes en la posición especificada de una matriz de bytes.Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

ToUInt16(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 16 bits sin signo.Converts a read-only byte-span into a 16-bit unsigned integer.

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.Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.

ToUInt32(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 32 bits sin signo.Converts a read-only byte span into a 32-bit unsigned integer.

ToUInt64(Byte[], Int32)

Devuelve un entero de 64 bits sin signo convertido a partir de ocho bytes en la posición especificada de una matriz de bytes.Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.

ToUInt64(ReadOnlySpan<Byte>)

Convierte los bytes en un valor Long sin signo.Converts bytes into an unsigned long.

TryWriteBytes(Span<Byte>, Boolean)

Convierte un valor booleano en un intervalo de bytes.Converts a Boolean into a span of bytes.

TryWriteBytes(Span<Byte>, Char)

Convierte un carácter en un intervalo de bytes.Converts a character into a span of bytes.

TryWriteBytes(Span<Byte>, Double)

Convierte un valor de punto flotante de precisión doble en un intervalo de bytes.Converts a double-precision floating-point value into a span of bytes.

TryWriteBytes(Span<Byte>, Int16)

Convierte un entero de 16 bits con signo en un intervalo de bytes.Converts a 16-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Int32)

Convierte un entero de 32 bits con signo en un intervalo de bytes.Converts a 32-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Int64)

Convierte un entero de 64 bits con signo en un intervalo de bytes.Converts a 64-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Single)

Convierte un valor de punto flotante de precisión doble en un intervalo de bytes.Converts a double-precision floating-point value into a span of bytes.

TryWriteBytes(Span<Byte>, UInt16)

Convierte un entero de 16 bits sin signo en un intervalo de bytes.Converts an unsigned 16-bit integer into a span of bytes.

TryWriteBytes(Span<Byte>, UInt32)

Convierte un entero de 32 bits sin signo en un intervalo de bytes.Converts a 32-bit unsigned integer into a span of bytes.

TryWriteBytes(Span<Byte>, UInt64)

Convierte un entero de 64 bits sin signo en un intervalo de bytes.Converts an unsigned 64-bit integer into a span of bytes.

Se aplica a

Consulte también: