BitConverter Klasse

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: BitConverter.cs

Quelle:: BitConverter.cs

Quelle:: BitConverter.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

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

Vererbung: Object
BitConverter

Beispiele

Im folgenden Codebeispiel wird die Verwendung mehrerer BitConverter Klassenmethoden veranschaulicht.

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

Hinweise

Die BitConverter Klasse hilft dabei, Werttypen in ihrer grundlegenden Form als Eine Reihe von Bytes zu bearbeiten. Ein Byte wird als eine 8-Bit-ganzzahl ohne Vorzeichen definiert. Die BitConverter Klasse enthält statische Methoden zum Konvertieren der einzelnen Grundtypen in und aus einem Bytearray, wie die folgende Tabelle veranschaulicht.

Art	In Bytekonvertierung	Von Bytekonvertierung
Boolean	GetBytes(Boolean)	ToBoolean
Char	GetBytes(Char)	ToChar
Double	GetBytes(Double) -oder- DoubleToInt64Bits(Double) -oder- DoubleToUInt64Bits(Double)	ToDouble -oder- Int64BitsToDouble -oder- UInt64BitsToDouble
Half	GetBytes(Half) -oder- HalfToInt16Bits(Half) -oder- HalfToUInt16Bits(Half)	ToHalf -oder- Int16BitsToHalf -oder- UInt16BitsToHalf
Int16	GetBytes(Int16)	ToInt16
Int32	GetBytes(Int32)	ToInt32
Int64	GetBytes(Int64)	ToInt64
Single	GetBytes(Single) -oder- SingleToInt32Bits(Single) -oder- SingleToUInt32Bits(Single)	ToSingle -oder- Int32BitsToSingle -oder- UInt32BitsToSingle
UInt16	GetBytes(UInt16)	ToUInt16
UInt32	GetBytes(UInt32)	ToUInt32
UInt64	GetBytes(UInt64)	ToUInt64

Wenn Sie BitConverter Methoden für Roundtripdaten verwenden, stellen Sie sicher, dass die GetBytes Überladung und die ToType-Methode denselben Typ angeben. Wie im folgenden Beispiel dargestellt, kann das Wiederherstellen eines Arrays, das eine signierte ganze Zahl darstellt, durch Aufrufen der ToUInt32-Methode zu einem Wert führen, der sich vom Ursprünglichen unterscheidet. Weitere Informationen finden Sie unter Arbeiten mit signierten nicht dezimalen und bitweisen Werten.

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

Die Reihenfolge der Byte im Array, das von den GetBytes Methodenüberladungen (sowie die Reihenfolge der Bits in der von der DoubleToInt64Bits Methode zurückgegebenen Ganzzahl) zurückgegeben wird, hängt davon ab, ob die Computerarchitektur little-endian oder big-endian ist. Ebenso hängt die Reihenfolge der Bytes im Array und von den ToIntegerValue- Methoden und der ToChar-Methode davon ab, ob die Computerarchitektur little-endian oder big-endian ist. Die Endianität einer Architektur wird durch die IsLittleEndian Eigenschaft angegeben, die true auf Little-End-Systemen zurückgibt und auf Big-End-Systemen false. Auf kleinen endischen Systemen gehen Bytes in niedrigerer Reihenfolge vor Byte höherer Reihenfolge vor. Auf big-endian system, higher-order bytes precede lower-order bytes. In der folgenden Tabelle wird der Unterschied in den Bytearrays veranschaulicht, die sich daraus ergeben, dass die ganze Zahl 1.234.567.890 (0x499602D2) an die GetBytes(Int32)-Methode übergeben wird. Die Bytes werden in der Reihenfolge des Bytes bei Index 0 bis zum Byte bei Index 3 aufgelistet.


Little-Endian	D2-02-96-49
Big-Endian	49-96-02-D2

Da der Rückgabewert einiger Methoden von der Systemarchitektur abhängt, achten Sie beim Übertragen von Bytedaten über computergrenzen hinweg:

Wenn alle Systeme, die Daten senden und empfangen, garantiert die gleiche Endianität haben, muss nichts an den Daten vorgenommen werden.

Wenn Systeme, die Daten senden und empfangen, unterschiedliche Endianität aufweisen können, übermitteln Sie daten immer in einer bestimmten Reihenfolge. Dies bedeutet, dass die Reihenfolge der Bytes im Array möglicherweise vor dem Senden oder nach dem Empfang umgekehrt werden muss. Eine gängige Konvention besteht darin, Daten in der Bytereihenfolge (Big-Endian-Reihenfolge) zu übertragen. Im folgenden Beispiel wird eine Implementierung zum Senden eines ganzzahligen Werts in der Bytereihenfolge des Netzwerks bereitgestellt.

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

Wenn Systeme, die Daten senden und empfangen, unterschiedliche Endianität aufweisen können und die zu übertragenden Daten aus signierten Ganzzahlen bestehen, rufen Sie die IPAddress.HostToNetworkOrder Methode auf, um die Daten in die Netzwerkbytereihenfolge und die IPAddress.NetworkToHostOrder-Methode zu konvertieren, um sie in die vom Empfänger erforderliche Reihenfolge zu konvertieren.

Felder

IsLittleEndian

Gibt die Bytereihenfolge ("Endianität") an, in der Daten in dieser Computerarchitektur gespeichert werden.

Methoden

DoubleToInt64Bits(Double)	Konvertiert die angegebene Gleitkommazahl mit doppelter Genauigkeit in eine 64-Bit-Ganzzahl mit Vorzeichen.
DoubleToUInt64Bits(Double)	Konvertiert die angegebene Gleitkommazahl mit doppelter Genauigkeit in eine 64-Bit-ganzzahl ohne Vorzeichen.
GetBytes(Boolean)	Gibt den angegebenen booleschen Wert als Bytearray zurück.
GetBytes(Char)	Gibt den angegebenen Unicode-Zeichenwert als Bytearray zurück.
GetBytes(Double)	Gibt den angegebenen Gleitkommawert mit doppelter Genauigkeit als Bytearray zurück.
GetBytes(Half)	Gibt den angegebenen Gleitkommawert mit halber Genauigkeit als Bytearray zurück.
GetBytes(Int128)	Gibt den angegebenen ganzzahligen 128-Bit-Ganzzahlwert als Bytearray zurück.
GetBytes(Int16)	Gibt den angegebenen ganzzahligen 16-Bit-Ganzzahlwert als Bytearray zurück.
GetBytes(Int32)	Gibt den angegebenen ganzzahligen 32-Bit-Wert als Bytearray zurück.
GetBytes(Int64)	Gibt den angegebenen ganzzahligen 64-Bit-Wert als Bytearray zurück.
GetBytes(Single)	Gibt den angegebenen Gleitkommawert mit einfacher Genauigkeit als Bytearray zurück.
GetBytes(UInt128)	Gibt den angegebenen ganzzahligen 128-Bit-Wert ohne Vorzeichen als Bytearray zurück.
GetBytes(UInt16)	Gibt den angegebenen ganzzahligen 16-Bit-Wert ohne Vorzeichen als Bytearray zurück.
GetBytes(UInt32)	Gibt den angegebenen ganzzahligen 32-Bit-Wert ohne Vorzeichen als Bytearray zurück.
GetBytes(UInt64)	Gibt den angegebenen ganzzahligen 64-Bit-Wert ohne Vorzeichen als Bytearray zurück.
HalfToInt16Bits(Half)	Wandelt einen Gleitkommawert mit halber Genauigkeit in eine 16-Bit-Ganzzahl um.
HalfToUInt16Bits(Half)	Wandelt die angegebene Gleitkommazahl mit halber Genauigkeit in eine 16-Bit-ganzzahl ohne Vorzeichen um.
Int16BitsToHalf(Int16)	Interpretiert den angegebenen ganzzahligen 16-Bit-Ganzzahlwert erneut als Gleitkommawert mit halber Genauigkeit.
Int32BitsToSingle(Int32)	Interpretiert die angegebene 32-Bit-Ganzzahl als Gleitkommawert mit einfacher Genauigkeit neu.
Int64BitsToDouble(Int64)	Interpretiert die angegebene 64-Bit-ganzzahlige Vorzeichen auf eine Gleitkommazahl mit doppelter Genauigkeit neu.
SingleToInt32Bits(Single)	Wandelt einen Gleitkommawert mit einfacher Genauigkeit in eine ganze Zahl um.
SingleToUInt32Bits(Single)	Wandelt die angegebene Gleitkommazahl mit einfacher Genauigkeit in eine 32-Bit-ganzzahl ohne Vorzeichen um.
ToBoolean(Byte[], Int32)	Gibt einen booleschen Wert zurück, der aus dem Byte an einer angegebenen Position in einem Bytearray konvertiert wird.
ToBoolean(ReadOnlySpan<Byte>)	Konvertiert einen schreibgeschützten Bytebereich in einen booleschen Wert.
ToChar(Byte[], Int32)	Gibt ein Unicode-Zeichen zurück, das aus zwei Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToChar(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in ein Zeichen um.
ToDouble(Byte[], Int32)	Gibt eine Gleitkommazahl mit doppelter Genauigkeit zurück, die von acht Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToDouble(ReadOnlySpan<Byte>)	Konvertiert einen schreibgeschützten Bytebereich in einen Gleitkommawert mit doppelter Genauigkeit.
ToHalf(Byte[], Int32)	Gibt eine Gleitkommazahl mit halber Genauigkeit zurück, die von zwei Bytes an einer angegebenen Position in einem Bytearray konvertiert wurde.
ToHalf(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in einen Gleitkommawert mit halber Genauigkeit um.
ToInt128(Byte[], Int32)	Gibt eine 128-Bit-Ganzzahl zurück, die aus sechzehn Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToInt128(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in eine 128-Bit-Ganzzahl um.
ToInt16(Byte[], Int32)	Gibt eine 16-Bit-Ganzzahl zurück, die aus zwei Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToInt16(ReadOnlySpan<Byte>)	Konvertiert einen schreibgeschützten Bytebereich in eine 16-Bit-Ganzzahl mit Vorzeichen.
ToInt32(Byte[], Int32)	Gibt eine 32-Bit-Ganzzahl zurück, die von vier Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToInt32(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in eine 32-Bit-Ganzzahl um.
ToInt64(Byte[], Int32)	Gibt eine 64-Bit-Ganzzahl zurück, die aus acht Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToInt64(ReadOnlySpan<Byte>)	Konvertiert einen schreibgeschützten Bytebereich in eine 64-Bit-Ganzzahl mit Vorzeichen.
ToSingle(Byte[], Int32)	Gibt eine Gleitkommazahl mit einfacher Genauigkeit zurück, die von vier Byte an einer angegebenen Position in einem Bytearray konvertiert wird.
ToSingle(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in einen Gleitkommawert mit einfacher Genauigkeit um.
ToString(Byte[])	Wandelt den numerischen Wert jedes Elements eines angegebenen Bytearrays in die entsprechende Hexadezimalzeichenfolgendarstellung um.
ToString(Byte[], Int32)	Wandelt den numerischen Wert jedes Elements eines angegebenen Teilarrays von Bytes in die entsprechende Hexadezimalzeichenfolgendarstellung um.
ToString(Byte[], Int32, Int32)	Wandelt den numerischen Wert jedes Elements eines angegebenen Teilarrays von Bytes in die entsprechende Hexadezimalzeichenfolgendarstellung um.
ToUInt128(Byte[], Int32)	Gibt eine 128-Bit-ganzzahl ohne Vorzeichen zurück, die von vier Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToUInt128(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in eine 128-Bit-ganzzahl ohne Vorzeichen um.
ToUInt16(Byte[], Int32)	Gibt eine 16-Bit-ganzzahl ohne Vorzeichen zurück, die von zwei Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToUInt16(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in eine 16-Bit-ganzzahl ohne Vorzeichen um.
ToUInt32(Byte[], Int32)	Gibt eine 32-Bit-ganzzahl ohne Vorzeichen zurück, die von vier Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToUInt32(ReadOnlySpan<Byte>)	Wandelt einen schreibgeschützten Bytebereich in eine 32-Bit-ganzzahl ohne Vorzeichen um.
ToUInt64(Byte[], Int32)	Gibt eine 64-Bit-ganzzahl ohne Vorzeichen zurück, die von acht Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.
ToUInt64(ReadOnlySpan<Byte>)	Wandelt Bytes in eine nicht signierte Lange um.
TryWriteBytes(Span<Byte>, Boolean)	Wandelt einen booleschen Wert in einen Bytebereich um.
TryWriteBytes(Span<Byte>, Char)	Wandelt ein Zeichen in einen Bytebereich um.
TryWriteBytes(Span<Byte>, Double)	Wandelt einen Gleitkommawert mit doppelter Genauigkeit in eine Bytespanne um.
TryWriteBytes(Span<Byte>, Half)	Wandelt einen Gleitkommawert mit halber Genauigkeit in einen Bytebereich um.
TryWriteBytes(Span<Byte>, Int128)	Wandelt eine 128-Bit-ganzzahlige Vorzeichen in einen Bytebereich um.
TryWriteBytes(Span<Byte>, Int16)	Wandelt eine 16-Bit-ganzzahlige Vorzeichen in einen Bytebereich um.
TryWriteBytes(Span<Byte>, Int32)	Wandelt eine 32-Bit-ganzzahlige Vorzeichen in einen Bytebereich um.
TryWriteBytes(Span<Byte>, Int64)	Wandelt eine 64-Bit-ganzzahlige Vorzeichen in einen Bytebereich um.
TryWriteBytes(Span<Byte>, Single)	Wandelt einen Gleitkommawert mit einfacher Genauigkeit in eine Bytespanne um.
TryWriteBytes(Span<Byte>, UInt128)	Wandelt eine 128-Bit-ganzzahl ohne Vorzeichen in einen Bytebereich um.
TryWriteBytes(Span<Byte>, UInt16)	Wandelt eine nicht signierte 16-Bit-Ganzzahl in einen Bytebereich um.
TryWriteBytes(Span<Byte>, UInt32)	Wandelt eine 32-Bit-ganzzahl ohne Vorzeichen in einen Bytebereich um.
TryWriteBytes(Span<Byte>, UInt64)	Wandelt eine nicht signierte 64-Bit-Ganzzahl in einen Bytebereich um.
UInt16BitsToHalf(UInt16)	Wandelt die angegebene 16-Bit-ganzzahl ohne Vorzeichen in eine Gleitkommazahl mit halber Genauigkeit um.
UInt32BitsToSingle(UInt32)	Wandelt die angegebene 32-Bit-ganzzahl ohne Vorzeichen in eine Gleitkommazahl mit einfacher Genauigkeit um.
UInt64BitsToDouble(UInt64)	Konvertiert die angegebene 64-Bit-ganzzahl ohne Vorzeichen in eine Gleitkommazahl mit doppelter Genauigkeit.

Gilt für:

Weitere Informationen

Byte

Freigeben über