BitConverter.ToSingle Método

Definição

Sobrecargas

ToSingle(ReadOnlySpan<Byte>)

Converte um intervalo de bytes somente leitura em um valor de ponto flutuante de precisão dupla.Converts a read-only byte span into a double-precision floating-point value.

ToSingle(Byte[], Int32)

Retorna um número de ponto flutuante de precisão simples convertido de quatro bytes em uma posição especificada em uma 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>)

Converte um intervalo de bytes somente leitura em um valor de ponto flutuante de precisão dupla.Converts a read-only byte span into a double-precision floating-point value.

public:
 static float ToSingle(ReadOnlySpan<System::Byte> value);
public static float ToSingle (ReadOnlySpan<byte> value);
static member ToSingle : ReadOnlySpan<byte> -> single
Public Shared Function ToSingle (value As ReadOnlySpan(Of Byte)) As Single

Parâmetros

value
ReadOnlySpan<Byte>

Um intervalo somente leitura que contém os bytes a serem convertidos.A read-only span containing the bytes to convert.

Retornos

Um valor de ponto flutuante de precisão dupla que representa os bytes convertidos.A double-precision floating-point value representing the converted bytes.

Exceções

O tamanho de value é menor que o tamanho de um valor de Double.The length of value is less than the length of a Double value.

ToSingle(Byte[], Int32)

Retorna um número de ponto flutuante de precisão simples convertido de quatro bytes em uma posição especificada em uma matriz de bytes.Returns a single-precision floating point number converted from four bytes at a specified position in a byte array.

public:
 static float ToSingle(cli::array <System::Byte> ^ value, int startIndex);
public static float ToSingle (byte[] value, int startIndex);
static member ToSingle : byte[] * int -> single
Public Shared Function ToSingle (value As Byte(), startIndex As Integer) As Single

Parâmetros

value
Byte[]

Uma matriz de bytes.An array of bytes.

startIndex
Int32

A posição inicial dentro de value.The starting position within value.

Retornos

Um número de ponto flutuante de precisão simples formado por quatro bytes, começando em startIndex.A single-precision floating point number formed by four bytes beginning at startIndex.

Exceções

startIndex é maior ou igual ao tamanho de value menos 3, e é menor ou igual ao tamanho de value menos 1.startIndex is greater than or equal to the length of value minus 3, and is less than or equal to the length of value minus 1.

value é null.value is null.

startIndex é menor que zero ou maior que o tamanho de value menos 1.startIndex is less than zero or greater than the length of value minus 1.

Exemplos

O exemplo de código a seguir converte elementos de matrizes Byte em valores Single com o método ToSingle.The following code example converts elements of Byte arrays to Single values with the ToSingle method.

// Example of the BitConverter::ToSingle method.
using namespace System;

// Convert four byte array elements to a float and display it.
void BAToSingle( array<unsigned char>^bytes, int index )
{
   float value = BitConverter::ToSingle( bytes, index );
   Console::WriteLine( "{0,5}{1,17}{2,18:E7}", index, BitConverter::ToString( bytes, index, 4 ), value );
}


// Display a byte array, using multiple lines if necessary.
void WriteMultiLineByteArray( array<unsigned char>^bytes )
{
   const int rowSize = 20;
   int iter;
   Console::WriteLine( "initial unsigned char array" );
   Console::WriteLine( "---------------------------" );
   for ( iter = 0; iter < bytes->Length - rowSize; iter += rowSize )
   {
      Console::Write( BitConverter::ToString( bytes, iter, rowSize ) );
      Console::WriteLine( "-" );

   }
   Console::WriteLine( BitConverter::ToString( bytes, iter ) );
   Console::WriteLine();
}

int main()
{
   array<unsigned char>^byteArray = {0,0,0,0,128,63,0,0,112,65,0,255,127,71,0,0,128,59,0,0,128,47,73,70,131,5,75,6,158,63,77,6,158,63,80,6,158,63,30,55,190,121,255,255,127,255,255,127,127,1,0,0,0,192,255,0,0,128,255,0,0,128,127};
   Console::WriteLine( "This example of the BitConverter::ToSingle( unsigned "
   "char[ ], int ) \nmethod generates the following output. It "
   "converts elements of a \nbyte array to float values.\n" );
   WriteMultiLineByteArray( byteArray );
   Console::WriteLine( "{0,5}{1,17}{2,18:E7}", "index", "array elements", "float" );
   Console::WriteLine( "{0,5}{1,17}{2,18:E7}", "-----", "--------------", "-----" );
   
   // Convert byte array elements to float values.
   BAToSingle( byteArray, 0 );
   BAToSingle( byteArray, 2 );
   BAToSingle( byteArray, 6 );
   BAToSingle( byteArray, 10 );
   BAToSingle( byteArray, 14 );
   BAToSingle( byteArray, 18 );
   BAToSingle( byteArray, 22 );
   BAToSingle( byteArray, 26 );
   BAToSingle( byteArray, 30 );
   BAToSingle( byteArray, 34 );
   BAToSingle( byteArray, 38 );
   BAToSingle( byteArray, 42 );
   BAToSingle( byteArray, 45 );
   BAToSingle( byteArray, 49 );
   BAToSingle( byteArray, 51 );
   BAToSingle( byteArray, 55 );
   BAToSingle( byteArray, 59 );
}

/*
This example of the BitConverter::ToSingle( unsigned char[ ], int )
method generates the following output. It converts elements of a
byte array to float values.

initial unsigned char array
---------------------------
00-00-00-00-80-3F-00-00-70-41-00-FF-7F-47-00-00-80-3B-00-00-
80-2F-49-46-83-05-4B-06-9E-3F-4D-06-9E-3F-50-06-9E-3F-1E-37-
BE-79-FF-FF-7F-FF-FF-7F-7F-01-00-00-00-C0-FF-00-00-80-FF-00-
00-80-7F

index   array elements             float
-----   --------------             -----
    0      00-00-00-00    0.0000000E+000
    2      00-00-80-3F    1.0000000E+000
    6      00-00-70-41    1.5000000E+001
   10      00-FF-7F-47    6.5535000E+004
   14      00-00-80-3B    3.9062500E-003
   18      00-00-80-2F    2.3283064E-010
   22      49-46-83-05    1.2345000E-035
   26      4B-06-9E-3F    1.2345671E+000
   30      4D-06-9E-3F    1.2345673E+000
   34      50-06-9E-3F    1.2345676E+000
   38      1E-37-BE-79    1.2345679E+035
   42      FF-FF-7F-FF   -3.4028235E+038
   45      FF-FF-7F-7F    3.4028235E+038
   49      01-00-00-00    1.4012985E-045
   51      00-00-C0-FF               NaN
   55      00-00-80-FF         -Infinity
   59      00-00-80-7F          Infinity
*/
// Example of the BitConverter.ToSingle method.
using System;

class BytesToSingleDemo
{
    const string formatter = "{0,5}{1,17}{2,18:E7}";
 
    // Convert four byte array elements to a float and display it.
    public static void BAToSingle( byte[ ] bytes, int index )
    {
        float value = BitConverter.ToSingle( bytes, index );

        Console.WriteLine( formatter, index, 
            BitConverter.ToString( bytes, index, 4 ), value );
    }

    // Display a byte array, using multiple lines if necessary.
    public static void WriteMultiLineByteArray( byte[ ] bytes )
    {
        const int rowSize = 20;
        int iter;

        Console.WriteLine( "initial byte array" );
        Console.WriteLine( "------------------" );

        for( iter = 0; iter < bytes.Length - rowSize; iter += rowSize )
        {
            Console.Write( 
                BitConverter.ToString( bytes, iter, rowSize ) );
            Console.WriteLine( "-" );
        }

        Console.WriteLine( BitConverter.ToString( bytes, iter ) );
        Console.WriteLine( );
    }

    public static void Main( )
    {
        byte[ ] byteArray = {
              0,   0,   0,   0, 128,  63,   0,   0, 112,  65, 
              0, 255, 127,  71,   0,   0, 128,  59,   0,   0, 
            128,  47,  73,  70, 131,   5,  75,   6, 158,  63, 
             77,   6, 158,  63,  80,   6, 158,  63,  30,  55, 
            190, 121, 255, 255, 127, 255, 255, 127, 127,   1, 
              0,   0,   0, 192, 255,   0,   0, 128, 255,   0, 
              0, 128, 127 };

        Console.WriteLine(
            "This example of the BitConverter.ToSingle( byte( ), " +
            "int ) \nmethod generates the following output. It " +
            "converts elements \nof a byte array to float values.\n" );

        WriteMultiLineByteArray( byteArray );

        Console.WriteLine( formatter, "index", "array elements", 
            "float" );
        Console.WriteLine( formatter, "-----", "--------------", 
            "-----" );
          
        // Convert byte array elements to float values.
        BAToSingle( byteArray, 0 );
        BAToSingle( byteArray, 2 );
        BAToSingle( byteArray, 6 );
        BAToSingle( byteArray, 10 );
        BAToSingle( byteArray, 14 );
        BAToSingle( byteArray, 18 );
        BAToSingle( byteArray, 22 );
        BAToSingle( byteArray, 26 );
        BAToSingle( byteArray, 30 );
        BAToSingle( byteArray, 34 );
        BAToSingle( byteArray, 38 );
        BAToSingle( byteArray, 42 );
        BAToSingle( byteArray, 45 );
        BAToSingle( byteArray, 49 );
        BAToSingle( byteArray, 51 );
        BAToSingle( byteArray, 55 );
        BAToSingle( byteArray, 59 );
    }
}

/*
This example of the BitConverter.ToSingle( byte( ), int )
method generates the following output. It converts elements
of a byte array to float values.

initial byte array
------------------
00-00-00-00-80-3F-00-00-70-41-00-FF-7F-47-00-00-80-3B-00-00-
80-2F-49-46-83-05-4B-06-9E-3F-4D-06-9E-3F-50-06-9E-3F-1E-37-
BE-79-FF-FF-7F-FF-FF-7F-7F-01-00-00-00-C0-FF-00-00-80-FF-00-
00-80-7F

index   array elements             float
-----   --------------             -----
    0      00-00-00-00    0.0000000E+000
    2      00-00-80-3F    1.0000000E+000
    6      00-00-70-41    1.5000000E+001
   10      00-FF-7F-47    6.5535000E+004
   14      00-00-80-3B    3.9062500E-003
   18      00-00-80-2F    2.3283064E-010
   22      49-46-83-05    1.2345000E-035
   26      4B-06-9E-3F    1.2345671E+000
   30      4D-06-9E-3F    1.2345673E+000
   34      50-06-9E-3F    1.2345676E+000
   38      1E-37-BE-79    1.2345679E+035
   42      FF-FF-7F-FF   -3.4028235E+038
   45      FF-FF-7F-7F    3.4028235E+038
   49      01-00-00-00    1.4012985E-045
   51      00-00-C0-FF               NaN
   55      00-00-80-FF         -Infinity
   59      00-00-80-7F          Infinity
*/
' Example of the BitConverter.ToSingle method.
Module BytesToSingleDemo

    Const formatter As String = "{0,5}{1,17}{2,18:E7}"
 
    ' Convert four Byte array elements to a Single and display it.
    Sub BAToSingle( bytes( ) As Byte, index As Integer )

        Dim value As Single = BitConverter.ToSingle( bytes, index )

        Console.WriteLine( formatter, index, _
            BitConverter.ToString( bytes, index, 4 ), value )
    End Sub 

    ' Display a Byte array, using multiple lines if necessary.
    Sub WriteMultiLineByteArray( bytes( ) As Byte )
       
        Const rowSize As Integer = 20 
        Dim iter As Integer

        Console.WriteLine( "initial Byte array" )
        Console.WriteLine( "------------------" )

        For iter = 0 To bytes.Length - rowSize - 1 Step rowSize
            Console.Write( _
                BitConverter.ToString( bytes, iter, rowSize ) )
            Console.WriteLine( "-" )
        Next iter

        Console.WriteLine( BitConverter.ToString( bytes, iter ) )
        Console.WriteLine( )
    End Sub

    Sub Main( )
        Dim byteArray as Byte( ) = { _
              0,   0,   0,   0, 128,  63,   0,   0, 112,  65, _
              0, 255, 127,  71,   0,   0, 128,  59,   0,   0, _
            128,  47,  73,  70, 131,   5,  75,   6, 158,  63, _
             77,   6, 158,  63,  80,   6, 158,  63,  30,  55, _
            190, 121, 255, 255, 127, 255, 255, 127, 127,   1, _
              0,   0,   0, 192, 255,   0,   0, 128, 255,   0, _
              0, 128, 127 }

        Console.WriteLine( _
            "This example of the BitConverter.ToSingle( Byte( ), " & _
            "Integer ) " & vbCrLf & "method generates the " & _
            "following output. It converts elements " & vbCrLf & _
            "of a Byte array to Single values." & vbCrLf )

        WriteMultiLineByteArray( byteArray )

        Console.WriteLine( formatter, "index", "array elements", _
            "Single" )
        Console.WriteLine( formatter, "-----", "--------------", _
            "------" )
          
        ' Convert Byte array elements to Single values.
        BAToSingle( byteArray, 0 )
        BAToSingle( byteArray, 2 )
        BAToSingle( byteArray, 6 )
        BAToSingle( byteArray, 10 )
        BAToSingle( byteArray, 14 )
        BAToSingle( byteArray, 18 )
        BAToSingle( byteArray, 22 )
        BAToSingle( byteArray, 26 )
        BAToSingle( byteArray, 30 )
        BAToSingle( byteArray, 34 )
        BAToSingle( byteArray, 38 )
        BAToSingle( byteArray, 42 )
        BAToSingle( byteArray, 45 )
        BAToSingle( byteArray, 49 )
        BAToSingle( byteArray, 51 )
        BAToSingle( byteArray, 55 )
        BAToSingle( byteArray, 59 )
    End Sub 
End Module

' This example of the BitConverter.ToSingle( Byte( ), Integer )
' method generates the following output. It converts elements
' of a Byte array to Single values.
' 
' initial Byte array
' ------------------
' 00-00-00-00-80-3F-00-00-70-41-00-FF-7F-47-00-00-80-3B-00-00-
' 80-2F-49-46-83-05-4B-06-9E-3F-4D-06-9E-3F-50-06-9E-3F-1E-37-
' BE-79-FF-FF-7F-FF-FF-7F-7F-01-00-00-00-C0-FF-00-00-80-FF-00-
' 00-80-7F
' 
' index   array elements            Single
' -----   --------------            ------
'     0      00-00-00-00    0.0000000E+000
'     2      00-00-80-3F    1.0000000E+000
'     6      00-00-70-41    1.5000000E+001
'    10      00-FF-7F-47    6.5535000E+004
'    14      00-00-80-3B    3.9062500E-003
'    18      00-00-80-2F    2.3283064E-010
'    22      49-46-83-05    1.2345000E-035
'    26      4B-06-9E-3F    1.2345671E+000
'    30      4D-06-9E-3F    1.2345673E+000
'    34      50-06-9E-3F    1.2345676E+000
'    38      1E-37-BE-79    1.2345679E+035
'    42      FF-FF-7F-FF   -3.4028235E+038
'    45      FF-FF-7F-7F    3.4028235E+038
'    49      01-00-00-00    1.4012985E-045
'    51      00-00-C0-FF               NaN
'    55      00-00-80-FF         -Infinity
'    59      00-00-80-7F          Infinity

Comentários

O método ToSingle converte os bytes do índice startIndex em startIndex + 3 em um valor Single.The ToSingle method converts the bytes from index startIndex to startIndex + 3 to a Single value. A ordem dos bytes na matriz deve refletir a endian da arquitetura do sistema do computador; para obter mais informações, consulte a seção comentários de BitConverter.The order of bytes in the array must reflect the endianness of the computer system's architecture; for more information, see the Remarks section of BitConverter.

Veja também

Aplica-se a