BitConverter Třída

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.Extensions.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Source:: BitConverter.cs

Source:: BitConverter.cs

Source:: BitConverter.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.

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

Dědičnost: Object
BitConverter

Příklady

Následující příklad kódu ukazuje použití několika BitConverter metod třídy.

// 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

Poznámky

Třída BitConverter pomáhá manipulovat s typy hodnot v jejich základní podobě, jako posloupnost bajtů. Bajt je definován jako 8bitové celé číslo bez znaménka. Třída BitConverter obsahuje statické metody pro převod každého z primitivních typů na pole bajtů a z pole bajtů, jak je znázorněno v následující tabulce.

Typ	Převod bajtů	Převod bajtů
Boolean	GetBytes(Boolean)	ToBoolean
Char	GetBytes(Char)	ToChar
Double	GetBytes(Double) -nebo- DoubleToInt64Bits(Double)	ToDouble -nebo- 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

Pokud používáte BitConverter metody k datům doby odezvy, ujistěte se, že GetBytes přetížení a To metoda Type určují stejný typ. Jak je znázorněno v následujícím příkladu, obnovení pole, které představuje celé číslo se signoum číslo voláním ToUInt32 metody může mít za následek hodnotu, která se liší od původního. Další informace najdete v tématu Práce s hodnotami bez desetinného čísla a bitové hodnoty.

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

Pořadí bajtů v poli vrácené přetížením GetBytes metody (stejně jako pořadí bitů v celočíselném čísle vráceném metodou DoubleToInt64Bits ) závisí na tom, zda je architektura počítače little-endian nebo big-endian. Podobně pořadí bajtů v poli a vrácené ToIntegerValue metody a ToChar metoda závisí na tom, zda je architektura počítače little-endian nebo big-endian. Endiálnost architektury je indikována IsLittleEndian vlastností , která se vrací u true systémů little-endian a false systémů big-endian. V systémech little-endian bajty nižšího řádu předcházejí bajtům vyššího řádu. V systému big-endian jsou bajty vyššího řádu před bajty nižšího řádu. Následující tabulka znázorňuje rozdíl v bajtových polích, který je výsledkem předání celého čísla 1 234 567 890 (0x499602D2) metodě GetBytes(Int32) . Bajty jsou uvedeny v pořadí od bajtu v indexu 0 do bajtu v indexu 3.


Little-endian	D2-02-96-49
Big-endian	49-96-02-D2

Vzhledem k tomu, že návratová hodnota některých metod závisí na architektuře systému, při přenosu bajtů dat za hranice počítače buďte opatrní:

Pokud je zaručeno, že všechny systémy, které odesílají a přijímají data, budou mít stejnou koncovost, nemusí se s daty nic dělat.

Pokud systémy, které odesílají a přijímají data, můžou mít různou koncovost, vždy přenášet data v určitém pořadí. To znamená, že pořadí bajtů v poli může být nutné obrátit před jejich odesláním nebo po jejich přijetí. Běžnou konvencí je přenos dat v pořadí bajtů sítě (big-endian). Následující příklad poskytuje implementaci pro odesílání celočíselné hodnoty v pořadí bajtů sítě.

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

Pokud systémy, které odesílají a přijímají data, mohou mít různou endiálnost a data, která se mají přenášet, se skládají ze signedýchch edicí, volejte IPAddress.HostToNetworkOrder metodu pro převod dat na síťové pořadí bajtů a metodu IPAddress.NetworkToHostOrder , která je převede na pořadí požadované příjemcem.

Pole

IsLittleEndian

Určuje pořadí bajtů ("endianness"), ve kterém jsou data uložena v této počítačové architektuře.

Metody

DoubleToInt64Bits(Double)	Převede zadané číslo s plovoucí desetinou čárkou s dvojitou přesností na 64bitové celé číslo se dvěma čísly.
DoubleToUInt64Bits(Double)	Převede zadané číslo s plovoucí desetinou čárkou s dvojitou přesností na 64bitové celé číslo bez znaménka.
GetBytes(Boolean)	Vrátí zadanou logickou hodnotu jako bajtové pole.
GetBytes(Char)	Vrátí zadanou hodnotu znaku Unicode jako pole bajtů.
GetBytes(Double)	Vrátí zadanou hodnotu dvojité přesnosti s plovoucí desetinou čárkou jako matici bajtů.
GetBytes(Half)	Vrátí zadanou hodnotu s plovoucí desetinou čárkou s poloviční přesností jako pole bajtů.
GetBytes(Int128)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
GetBytes(Int16)	Vrátí zadanou 16bitovou celočíselnou hodnotu jako pole bajtů.
GetBytes(Int32)	Vrátí zadanou 32bitovou celočíselnou hodnotu jako pole bajtů.
GetBytes(Int64)	Vrátí zadanou 64bitovou celočíselnou hodnotu jako pole bajtů.
GetBytes(Single)	Vrátí zadanou hodnotu s plovoucí desetinou čárkou s jednoduchou přesností jako pole bajtů.
GetBytes(UInt128)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
GetBytes(UInt16)	Vrátí zadanou 16bitovou celočíselnou hodnotu bez znaménka jako pole bajtů.
GetBytes(UInt32)	Vrátí zadanou 32bitovou celočíselnou hodnotu bez znaménka jako pole bajtů.
GetBytes(UInt64)	Vrátí zadanou 64bitovou celočíselnou hodnotu bez znaménka jako pole bajtů.
HalfToInt16Bits(Half)	Převede hodnotu s plovoucí desetinou čárkou s poloviční přesností na 16bitové celé číslo.
HalfToUInt16Bits(Half)	Převede zadané číslo s plovoucí desetinou čárkou s poloviční přesností na 16bitové celé číslo bez znaménka.
Int16BitsToHalf(Int16)	Reinterprets the 16-bit signed integer value as a half-precision floating-point value.
Int32BitsToSingle(Int32)	Znovu interpretuje zadané 32bitové celé číslo jako hodnotu s plovoucí desetinou čárkou s jednou přesností.
Int64BitsToDouble(Int64)	Reinterprets zadané 64bitové 64bitové celé číslo se dvěma přesnostmi s plovoucí desetinou čárkou.
SingleToInt32Bits(Single)	Převede hodnotu s plovoucí desetinou čárkou s jednoduchou přesností na celé číslo.
SingleToUInt32Bits(Single)	Převede zadané číslo s plovoucí desetinou čárkou s jednoduchou přesností na 32bitové celé číslo bez znaménka.
ToBoolean(Byte[], Int32)	Vrátí logickou hodnotu převedenou z bajtu na zadané pozici v bajtovém poli.
ToBoolean(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na logickou hodnotu.
ToChar(Byte[], Int32)	Vrátí znak Unicode převedený ze dvou bajtů na zadané pozici v bajtovém poli.
ToChar(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na znak.
ToDouble(Byte[], Int32)	Vrátí číslo s plovoucí desetinou čárkou s dvojitou přesností převedené z osmi bajtů na zadané pozici v bajtové matici.
ToDouble(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na hodnotu s plovoucí desetinou čárkou s dvojitou přesností.
ToHalf(Byte[], Int32)	Vrátí číslo s plovoucí desetinou čárkou s poloviční přesností převedené ze dvou bajtů na zadané pozici v bajtovém poli.
ToHalf(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na hodnotu s plovoucí desetinou čárkou s poloviční přesností.
ToInt128(Byte[], Int32)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
ToInt128(ReadOnlySpan<Byte>)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
ToInt16(Byte[], Int32)	Vrátí 16bitové celé číslo se dvěma bajty převedené ze dvou bajtů na zadané pozici v bajtovém poli.
ToInt16(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na 16bitové celé číslo se signedýmm systémem.
ToInt32(Byte[], Int32)	Vrátí 32bitové celé číslo se signoumi adresou převedené ze čtyř bajtů na zadané pozici v bajtovém poli.
ToInt32(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na 32bitové celé číslo se signedýmm systémem.
ToInt64(Byte[], Int32)	Vrátí 64bitové celé číslo se signýmým kódem převedené z osmi bajtů na zadané pozici v bajtovém poli.
ToInt64(ReadOnlySpan<Byte>)	Převede bajtový rozsah jen pro čtení na 64bitové celé číslo se signoumi sadou.
ToSingle(Byte[], Int32)	Vrátí číslo s plovoucí desetinou čárkou s jednoduchou přesností převedené ze čtyř bajtů na zadané pozici v bajtovém poli.
ToSingle(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na hodnotu s plovoucí desetinou čárkou s jednoduchou přesností.
ToString(Byte[])	Převede číselnou hodnotu každého prvku zadaného pole bajtů na ekvivalentní šestnáctkové řetězcové vyjádření.
ToString(Byte[], Int32)	Převede číselnou hodnotu každého prvku zadaného dílčího pole bajtů na jeho ekvivalentní šestnáctkové řetězcové vyjádření.
ToString(Byte[], Int32, Int32)	Převede číselnou hodnotu každého prvku zadaného dílčího pole bajtů na jeho ekvivalentní šestnáctkové řetězcové vyjádření.
ToUInt128(Byte[], Int32)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
ToUInt128(ReadOnlySpan<Byte>)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
ToUInt16(Byte[], Int32)	Vrátí 16bitové celé číslo bez znaménka převedené ze dvou bajtů na zadané pozici v bajtovém poli.
ToUInt16(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na 16bitové celé číslo bez znaménka.
ToUInt32(Byte[], Int32)	Vrátí 32bitové celé číslo bez znaménka převedené ze čtyř bajtů na zadané pozici v bajtovém poli.
ToUInt32(ReadOnlySpan<Byte>)	Převede rozsah bajtů jen pro čtení na 32bitové celé číslo bez znaménka.
ToUInt64(Byte[], Int32)	Vrátí 64bitové celé číslo bez znaménka převedené z osmi bajtů na zadané pozici v bajtovém poli.
ToUInt64(ReadOnlySpan<Byte>)	Převede bajty na dlouhý bez znaménka.
TryWriteBytes(Span<Byte>, Boolean)	Převede logickou hodnotu na rozsah bajtů.
TryWriteBytes(Span<Byte>, Char)	Převede znak na rozsah bajtů.
TryWriteBytes(Span<Byte>, Double)	Převede hodnotu s plovoucí desetinou čárkou s dvojitou přesností na rozsah bajtů.
TryWriteBytes(Span<Byte>, Half)	Převede hodnotu s plovoucí desetinou čárkou s poloviční přesností na rozsah bajtů.
TryWriteBytes(Span<Byte>, Int128)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
TryWriteBytes(Span<Byte>, Int16)	Převede 16bitové celé číslo se signedýmm sadou na rozsah bajtů.
TryWriteBytes(Span<Byte>, Int32)	Převede 32bitové celé číslo se signoumi sadou na rozsah bajtů.
TryWriteBytes(Span<Byte>, Int64)	Převede 64bitové celé číslo se signoumi sadou na rozsah bajtů.
TryWriteBytes(Span<Byte>, Single)	Převede hodnotu s plovoucí desetinou čárkou s jednoduchou přesností na rozsah bajtů.
TryWriteBytes(Span<Byte>, UInt128)	Převede základní datové typy na pole bajtů a pole bajtů na základní datové typy.
TryWriteBytes(Span<Byte>, UInt16)	Převede 16bitové celé číslo bez znaménka na rozsah bajtů.
TryWriteBytes(Span<Byte>, UInt32)	Převede 32bitové celé číslo bez znaménka na rozsah bajtů.
TryWriteBytes(Span<Byte>, UInt64)	Převede 64bitové celé číslo bez znaménka na rozsah bajtů.
UInt16BitsToHalf(UInt16)	Převede zadané 16bitové celé číslo bez znaménka na číslo s pohyblivou desetinou čárkou s poloviční přesností.
UInt32BitsToSingle(UInt32)	Převede zadané 32bitové celé číslo bez znaménka na číslo s plovoucí desetinou čárkou s jednoduchou přesností.
UInt64BitsToDouble(UInt64)	Převede zadané 64bitové celé číslo bez znaménka na číslo s plovoucí desetinou čárkou s dvojitou přesností.

Platí pro

Viz také

Byte