Compartir a través de


BitConverter Clase

Definición

Convierte los tipos de datos base en una matriz de bytes y una matriz de bytes en tipos de datos base.

public ref class BitConverter abstract sealed
public ref class BitConverter sealed
public static class BitConverter
public sealed class BitConverter
type BitConverter = class
Public Class BitConverter
Public NotInheritable Class BitConverter
Herencia
BitConverter

Ejemplos

En el ejemplo de código siguiente se muestra el uso de varios métodos de clase BitConverter.

// 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
*/
open System

let print: obj -> obj -> unit = printfn "%25O%30O"

let aDoubl = 0.1111111111111111111
let aSingl = 0.1111111111111111111f
let aLong = 1111111111111111111L
let anInt = 1111111111
let aShort = 11111s
let aChar = '*'
let aBool = true

printfn "This example of methods of the BitConverter class\ngenerates the following output.\n"
print "argument" "byte array"
print "--------" "----------"

// Convert values to Byte arrays and display them.
print aDoubl (BitConverter.ToString(BitConverter.GetBytes aDoubl))

print aSingl (BitConverter.ToString(BitConverter.GetBytes aSingl))

print aLong (BitConverter.ToString(BitConverter.GetBytes aLong))

print anInt (BitConverter.ToString(BitConverter.GetBytes anInt))

print aShort (BitConverter.ToString(BitConverter.GetBytes aShort))

print aChar (BitConverter.ToString(BitConverter.GetBytes aChar))

print 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 los tipos de valor en su forma fundamental, como una serie de bytes. Un byte se define como un entero de 8 bits sin signo. 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.

Tipo Conversión de bytes Conversión de bytes
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)
-o-
DoubleToInt64Bits(Double)
-o-
DoubleToUInt64Bits(Double)
ToDouble
-o-
Int64BitsToDouble
-o-
UInt64BitsToDouble
Half GetBytes(Half)
-o-
HalfToInt16Bits(Half)
-o-
HalfToUInt16Bits(Half)
ToHalf
-o-
Int16BitsToHalf
-o-
UInt16BitsToHalf
Int16 GetBytes(Int16) ToInt16
Int32 GetBytes(Int32) ToInt32
Int64 GetBytes(Int64) ToInt64
Single GetBytes(Single)
-o-
SingleToInt32Bits(Single)
-o-
SingleToUInt32Bits(Single)
ToSingle
-o-
Int32BitsToSingle
-o-
UInt32BitsToSingle
UInt16 GetBytes(UInt16) ToUInt16
UInt32 GetBytes(UInt32) ToUInt32
UInt64 GetBytes(UInt64) ToUInt64

Si usa métodos de BitConverter para los datos de ida y vuelta, asegúrese de que la sobrecarga de GetBytes y el método ToType especifique el mismo tipo. Como se muestra en el ejemplo siguiente, restaurar una matriz que representa un entero con signo llamando al método ToUInt32 puede dar lugar a un valor diferente del original. Para obtener más información, vea Trabajar con valores no decimales y bit a bit firmados.

using System;

public class Example
{
   public static void Main()
   {
      int value = -16;
      Byte[] bytes = BitConverter.GetBytes(value);

      // Convert bytes back to int.
      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
open System

let value = -16
let bytes = BitConverter.GetBytes value

// Convert bytes back to int.
let intValue = BitConverter.ToInt32(bytes, 0)
printfn $"""{value} = {intValue}: {if value.Equals intValue then "Round-trips" else "Does not round-trip"}"""

// Convert bytes to UInt32.
let uintValue = BitConverter.ToUInt32(bytes, 0)
printfn $"""{value} = {uintValue}: {if value.Equals uintValue then "Round-trips" else "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 bytes de la matriz devuelta por las sobrecargas del método GetBytes (así como el orden de bits en el entero devuelto por el método DoubleToInt64Bits) depende de si la arquitectura del equipo es little-endian o big-endian. Del mismo modo, el orden de bytes de la matriz y devuelto por los métodos ToIntegerValue y el método ToChar depende de si la arquitectura del equipo es little-endian o big-endian. La endianidad de una arquitectura se indica mediante la propiedad IsLittleEndian, que devuelve true en sistemas little-endian y false en sistemas big-endian. En los sistemas little-endian, los bytes de orden inferior preceden a bytes de orden superior. En el sistema big-endian, los bytes de orden superior preceden a los bytes de orden inferior. 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). Los bytes se muestran en orden del byte en el índice 0 al byte en el índice 3.

Little-endian D2-02-96-49
Big-endian 49-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 de la máquina:

  • Si se garantiza que todos los sistemas que envían y reciben datos tienen la misma endianidad, no es necesario hacer nada a los datos.

  • Si los sistemas que envían y reciben datos pueden tener una endianidad diferente, transmita siempre los datos en un orden determinado. Esto significa que es posible que el orden de bytes de la matriz tenga que invertirse antes de enviarlos o después de recibirlos. Una convención común es transmitir datos en orden de bytes de red (orden big-endian). En el ejemplo siguiente se proporciona una implementación para enviar un valor entero en orden de bytes de red.

    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
    
    open System
    
    let value = 12345678
    let bytes = BitConverter.GetBytes value
    printfn $"{BitConverter.ToString bytes}"
    
    if BitConverter.IsLittleEndian then
        Array.Reverse bytes
    
    printfn $"{BitConverter.ToString bytes}"
    // Call method to send byte stream across machine boundaries.
    
    // Receive byte stream from beyond machine boundaries.
    printfn $"{BitConverter.ToString bytes}"
    if BitConverter.IsLittleEndian then
        Array.Reverse bytes
    
    printfn $"{BitConverter.ToString bytes}"
    let result = BitConverter.ToInt32(bytes, 0)
    
    printfn $"Original value: {value}"
    printfn $"Returned value: {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 una endianidad diferente y los datos que se van a transmitir constan de enteros con signo, llame al método IPAddress.HostToNetworkOrder para convertir los datos en orden de bytes de red y el método IPAddress.NetworkToHostOrder para convertirlo en el orden requerido por el destinatario.

Campos

IsLittleEndian

Indica el orden de bytes ("endianness") en el que los datos se almacenan en esta arquitectura de equipo.

Métodos

DoubleToInt64Bits(Double)

Convierte el número de punto flotante de precisión doble especificado en un entero de 64 bits con signo.

DoubleToUInt64Bits(Double)

Convierte el número de punto flotante de precisión doble especificado en un entero de 64 bits sin signo.

GetBytes(Boolean)

Devuelve el valor booleano especificado como una matriz de bytes.

GetBytes(Char)

Devuelve el valor de carácter Unicode especificado como una matriz de bytes.

GetBytes(Double)

Devuelve el valor de punto flotante de precisión doble especificado como una matriz de bytes.

GetBytes(Half)

Devuelve el valor de punto flotante de precisión media especificado como una matriz de bytes.

GetBytes(Int128)

Devuelve el valor entero con signo de 128 bits especificado como una matriz de bytes.

GetBytes(Int16)

Devuelve el valor entero de 16 bits con signo especificado como una matriz de bytes.

GetBytes(Int32)

Devuelve el valor entero con signo de 32 bits especificado como una matriz de bytes.

GetBytes(Int64)

Devuelve el valor entero con signo de 64 bits especificado como una matriz de bytes.

GetBytes(Single)

Devuelve el valor de punto flotante de precisión única especificado como una matriz de bytes.

GetBytes(UInt128)

Devuelve el valor entero de 128 bits sin signo especificado como una matriz de bytes.

GetBytes(UInt16)

Devuelve el valor entero de 16 bits sin signo especificado como una matriz de bytes.

GetBytes(UInt32)

Devuelve el valor entero de 32 bits sin signo especificado como una matriz de bytes.

GetBytes(UInt64)

Devuelve el valor entero de 64 bits sin signo especificado como una matriz de bytes.

HalfToInt16Bits(Half)

Convierte un valor de punto flotante de precisión media en un entero de 16 bits.

HalfToUInt16Bits(Half)

Convierte el número de punto flotante de precisión media especificado en un entero de 16 bits sin signo.

Int16BitsToHalf(Int16)

Reinterpreta el valor entero con signo de 16 bits especificado como un valor de punto flotante de precisión media.

Int32BitsToSingle(Int32)

Reinterpreta el entero de 32 bits especificado como un valor de punto flotante de precisión sencilla.

Int64BitsToDouble(Int64)

Reinterpreta el entero con signo de 64 bits especificado en un número de punto flotante de precisión doble.

SingleToInt32Bits(Single)

Convierte un valor de punto flotante de precisión sencilla en un entero.

SingleToUInt32Bits(Single)

Convierte el número de punto flotante de precisión sencilla especificado en un entero de 32 bits sin signo.

ToBoolean(Byte[], Int32)

Devuelve un valor booleano convertido desde el byte en una posición especificada en una matriz de bytes.

ToBoolean(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un valor booleano.

ToChar(Byte[], Int32)

Devuelve un carácter Unicode convertido a partir de dos bytes en una posición especificada en una matriz de bytes.

ToChar(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un carácter.

ToDouble(Byte[], Int32)

Devuelve un número de punto flotante de precisión doble convertido de ocho bytes en una posición especificada en una matriz de bytes.

ToDouble(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un valor de punto flotante de precisión doble.

ToHalf(Byte[], Int32)

Devuelve un número de punto flotante de precisión media convertido a partir de dos bytes en una posición especificada en una matriz de bytes.

ToHalf(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un valor de punto flotante de precisión media.

ToInt128(Byte[], Int32)

Devuelve un entero de 128 bits con signo convertido de dieciséis bytes en una posición especificada en una matriz de bytes.

ToInt128(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 128 bits con signo.

ToInt16(Byte[], Int32)

Devuelve un entero de 16 bits con signo convertido a partir de dos bytes en una posición especificada en una matriz de bytes.

ToInt16(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 16 bits con signo.

ToInt32(Byte[], Int32)

Devuelve un entero de 32 bits con signo convertido de cuatro bytes en una posición especificada en una matriz de bytes.

ToInt32(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 32 bits con signo.

ToInt64(Byte[], Int32)

Devuelve un entero de 64 bits con signo convertido de ocho bytes en una posición especificada en una matriz de bytes.

ToInt64(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 64 bits con signo.

ToSingle(Byte[], Int32)

Devuelve un número de punto flotante de precisión sencilla convertido de cuatro bytes en una posición especificada en una matriz de bytes.

ToSingle(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un valor de punto flotante de precisión sencilla.

ToString(Byte[])

Convierte el valor numérico de cada elemento de una matriz especificada de bytes en su representación de cadena hexadecimal equivalente.

ToString(Byte[], Int32)

Convierte el valor numérico de cada elemento de una subbarra de bytes especificada en su representación de cadena hexadecimal equivalente.

ToString(Byte[], Int32, Int32)

Convierte el valor numérico de cada elemento de una subbarra de bytes especificada en su representación de cadena hexadecimal equivalente.

ToUInt128(Byte[], Int32)

Devuelve un entero de 128 bits sin signo convertido de cuatro bytes en una posición especificada en una matriz de bytes.

ToUInt128(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 128 bits sin signo.

ToUInt16(Byte[], Int32)

Devuelve un entero sin signo de 16 bits convertido a partir de dos bytes en una posición especificada en una matriz de bytes.

ToUInt16(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 16 bits sin signo.

ToUInt32(Byte[], Int32)

Devuelve un entero de 32 bits sin signo convertido de cuatro bytes en una posición especificada en una matriz de bytes.

ToUInt32(ReadOnlySpan<Byte>)

Convierte un intervalo de bytes de solo lectura en un entero de 32 bits sin signo.

ToUInt64(Byte[], Int32)

Devuelve un entero de 64 bits sin signo convertido a partir de ocho bytes en una posición especificada en una matriz de bytes.

ToUInt64(ReadOnlySpan<Byte>)

Convierte bytes en un long sin signo.

TryWriteBytes(Span<Byte>, Boolean)

Convierte un valor booleano en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Char)

Convierte un carácter en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Double)

Convierte un valor de punto flotante de precisión doble en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Half)

Convierte un valor de punto flotante de precisión media en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Int128)

Convierte un entero de 128 bits con signo en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Int16)

Convierte un entero de 16 bits con signo en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Int32)

Convierte un entero de 32 bits con signo en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Int64)

Convierte un entero de 64 bits con signo en un intervalo de bytes.

TryWriteBytes(Span<Byte>, Single)

Convierte un valor de punto flotante de precisión única en un intervalo de bytes.

TryWriteBytes(Span<Byte>, UInt128)

Convierte un entero de 128 bits sin signo en un intervalo de bytes.

TryWriteBytes(Span<Byte>, UInt16)

Convierte un entero de 16 bits sin signo en un intervalo de bytes.

TryWriteBytes(Span<Byte>, UInt32)

Convierte un entero de 32 bits sin signo en un intervalo de bytes.

TryWriteBytes(Span<Byte>, UInt64)

Convierte un entero de 64 bits sin signo en un intervalo de bytes.

UInt16BitsToHalf(UInt16)

Convierte el entero de 16 bits sin signo especificado en un número de punto flotante de precisión media.

UInt32BitsToSingle(UInt32)

Convierte el entero de 32 bits sin signo especificado en un número de punto flotante de precisión sencilla.

UInt64BitsToDouble(UInt64)

Convierte el entero de 64 bits sin signo especificado en un número de punto flotante de precisión doble.

Se aplica a

Consulte también