BitConverter Klasse

Definition

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
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 beim Bearbeiten von Werttypen in ihrer grundlegenden Form als Eine Reihe von Bytes. Ein Byte wird als eine 8-Bit-Ganzzahl ohne Vorzeichen definiert. Die BitConverter -Klasse enthält statische Methoden zum Konvertieren der einzelnen primitiven Typen in und aus einem Bytearray, wie in der folgenden Tabelle veranschaulicht.

Typ In Bytekonvertierung From-Byte-Konvertierung
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

- oder -

DoubleToInt64Bits(Double)
ToDouble

- oder -

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

Wenn Sie Methoden für Roundtripdaten verwenden BitConverter , stellen Sie sicher, dass die GetBytes Überladung und die ToType-Methode den gleichen Typ angeben. Wie das folgende Beispiel veranschaulicht, kann das Wiederherstellen eines Arrays, das eine ganze Zahl mit Vorzeichen darstellt, durch Aufrufen der ToUInt32 -Methode zu einem anderen Wert als dem originalen führen. 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 Bytereihenfolge im Array, das von den GetBytes Methodenüberladungen zurückgegeben wird (sowie die Reihenfolge der Bits in der ganzen Zahl, die von der DoubleToInt64Bits Methode zurückgegeben wird) hängt davon ab, ob die Computerarchitektur Little-Endian oder Big-Endian ist. Entsprechend hängt die Reihenfolge der Bytes im Array, die von den ToIntegerValue-Methoden und der ToChar -Methode zurückgegeben werden, davon ab, ob die Computerarchitektur Little-Endian oder Big-Endian ist. Die Endianität einer Architektur wird durch die -Eigenschaft angegeben, die IsLittleEndian auf Little-Endian-Systemen und false auf Big-Endian-Systemen zurückgibttrue. Auf Little-Endian-Systemen gehen Bytes niedrigerer Ordnung vor Bytes höherer Ordnung. Im Big-Endian-System gehen Bytes höherer Ordnung vor Bytes niedrigerer Reihenfolge. Die folgende Tabelle veranschaulicht den Unterschied in den Bytearrays, der sich aus der Übergabe der ganzen Zahl 1.234.567.890 (0x499602D2) an die GetBytes(Int32) -Methode ergibt. Die Bytes werden in der Reihenfolge vom Byte 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, sollten Sie bei der Übertragung von Bytedaten über Computergrenzen hinaus vorsichtig sein:

  • Wenn alle Systeme, die Daten senden und empfangen, garantiert die gleiche Endianität aufweisen, wurde nichts an den Daten unternommen.

  • Wenn Systeme, die Daten senden und empfangen, eine unterschiedliche Endianität aufweisen können, übertragen 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 Netzwerkbytereihenfolge (Big-Endian-Reihenfolge) zu übertragen. Im folgenden Beispiel wird eine Implementierung zum Senden eines ganzzahligen Werts in Netzwerkbytereihenfolge 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, eine unterschiedliche Endianität aufweisen können und die zu übertragenden Daten aus ganzzahligen Vorzeichen bestehen, rufen Sie die IPAddress.HostToNetworkOrder -Methode auf, um die Daten in die Netzwerkbytereihenfolge zu konvertieren, und die IPAddress.NetworkToHostOrder -Methode, um sie in die vom Empfänger erforderliche Reihenfolge zu konvertieren.

Felder

IsLittleEndian

Gibt die Bytereihenfolge (Endianwert) 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 Wert des angegebenen Unicode-Zeichens 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)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

GetBytes(Int16)

Gibt den Wert der angegebenen 16-Bit-Ganzzahl mit Vorzeichen als Bytearray zurück.

GetBytes(Int32)

Gibt den angegebenen ganzzahligen 32-Bit-Wert mit Vorzeichen als Bytearray zurück

GetBytes(Int64)

Gibt den angegebenen ganzzahligen 64-Bit-Wert mit Vorzeichen als Bytearray zurück.

GetBytes(Single)

Gibt den angegebenen Gleitkommawert mit einfacher Genauigkeit als Bytearray zurück.

GetBytes(UInt128)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

GetBytes(UInt16)

Gibt den Wert der angegebenen vorzeichenlosen 16-Bit-Ganzzahl als Bytearray zurück.

GetBytes(UInt32)

Gibt den Wert der angegebenen vorzeichenlosen 32-Bit-Ganzzahl als Bytearray zurück

GetBytes(UInt64)

Gibt den Wert der angegebenen vorzeichenlosen 64-Bit-Ganzzahl als Bytearray zurück

HalfToInt16Bits(Half)

Konvertiert einen Gleitkommawert mit halber Genauigkeit in eine 16-Bit-Ganzzahl.

HalfToUInt16Bits(Half)

Konvertiert die angegebene Gleitkommazahl mit halber Genauigkeit in eine 16-Bit-Ganzzahl ohne Vorzeichen.

Int16BitsToHalf(Int16)

Interpretiert den angegebenen 16-Bit-Ganzzahlwert mit Vorzeichen als Gleitkommawert mit halber Genauigkeit neu.

Int32BitsToSingle(Int32)

Interpretiert den angegebenen 32-Bit-Integerwert als Gleitkommawert mit einfacher Genauigkeit neu.

Int64BitsToDouble(Int64)

Interpretiert den angegebenen 64-Bit-Integerwert mit Vorzeichen als Gleitkommazahl mit doppelter Genauigkeit neu.

SingleToInt32Bits(Single)

Konvertiert einen Gleitkommawert mit einfacher Genauigkeit in einen Integerwert.

SingleToUInt32Bits(Single)

Konvertiert die angegebene Gleitkommazahl mit einfacher Genauigkeit in eine 32-Bit-Ganzzahl ohne Vorzeichen.

ToBoolean(Byte[], Int32)

Gibt einen booleschen Wert zurück, der aus dem Byte an der angegebenen Position eines Bytearrays konvertiert wurde

ToBoolean(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen booleschen Wert.

ToChar(Byte[], Int32)

Gibt ein Unicode-Zeichen zurück, das aus zwei Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToChar(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in ein Zeichen.

ToDouble(Byte[], Int32)

Gibt eine Gleitkommazahl mit doppelter Genauigkeit zurück, die aus acht Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToDouble(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen Gleitkommawert mit doppelter Genauigkeit.

ToHalf(Byte[], Int32)

Gibt eine Gleitkommazahl mit Laftgenauigkeit zurück, die aus zwei Bytes an einer angegebenen Position in einem Bytearray konvertiert wird.

ToHalf(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen Gleitkommawert mit halber Genauigkeit.

ToInt128(Byte[], Int32)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

ToInt128(ReadOnlySpan<Byte>)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

ToInt16(Byte[], Int32)

Gibt eine 16-Bit-Ganzzahl mit Vorzeichen zurück, die aus zwei Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToInt16(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen 16-Bit-Integerwert mit Vorzeichen.

ToInt32(Byte[], Int32)

Gibt eine 32-Bit-Ganzzahl mit Vorzeichen zurück, die aus vier Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToInt32(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen 32-Bit-Integerwert mit Vorzeichen.

ToInt64(Byte[], Int32)

Gibt eine 64-Bit-Ganzzahl mit Vorzeichen zurück, die aus acht Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToInt64(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen 64-Bit-Integerwert mit Vorzeichen.

ToSingle(Byte[], Int32)

Gibt eine Gleitkommazahl mit einfacher Genauigkeit zurück, die aus vier Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToSingle(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen Gleitkommawert mit einfacher Genauigkeit.

ToString(Byte[])

Konvertiert den numerischen Wert jedes Elements im angegebenen Bytearray in die entsprechende hexadezimale Zeichenfolgendarstellung.

ToString(Byte[], Int32)

Konvertiert den numerischen Wert jedes Elements in einem Teil des angegebenen Bytearrays in die entsprechende hexadezimale Zeichenfolgendarstellung.

ToString(Byte[], Int32, Int32)

Konvertiert den numerischen Wert jedes Elements in einem Teil des angegebenen Bytearrays in die entsprechende hexadezimale Zeichenfolgendarstellung.

ToUInt128(Byte[], Int32)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

ToUInt128(ReadOnlySpan<Byte>)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

ToUInt16(Byte[], Int32)

Gibt eine vorzeichenlose 16-Bit-Ganzzahl zurück, die aus zwei Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToUInt16(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen 16-Bit-Integerwert ohne Vorzeichen.

ToUInt32(Byte[], Int32)

Gibt eine vorzeichenlose 32-Bit-Ganzzahl zurück, die aus vier Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToUInt32(ReadOnlySpan<Byte>)

Konvertiert eine schreibgeschützte Bytespanne in einen 32-Bit-Integerwert ohne Vorzeichen.

ToUInt64(Byte[], Int32)

Gibt eine vorzeichenlose 64-Bit-Ganzzahl zurück, die aus acht Bytes an der angegebenen Position in einem Bytearray konvertiert wurde.

ToUInt64(ReadOnlySpan<Byte>)

Konvertiert Bytes in einen long-Wert ohne Vorzeichen.

TryWriteBytes(Span<Byte>, Boolean)

Konvertiert einen booleschen Wert in eine Bytespanne.

TryWriteBytes(Span<Byte>, Char)

Konvertiert ein Zeichen in eine Bytespanne.

TryWriteBytes(Span<Byte>, Double)

Konvertiert einen Gleitkommawert mit doppelter Genauigkeit in eine Bytespanne.

TryWriteBytes(Span<Byte>, Half)

Konvertiert einen Gleitkommawert mit halber Genauigkeit in eine Bytespanne.

TryWriteBytes(Span<Byte>, Int128)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

TryWriteBytes(Span<Byte>, Int16)

Konvertiert einen 16-Bit-Integerwert mit Vorzeichen in eine Bytespanne.

TryWriteBytes(Span<Byte>, Int32)

Konvertiert einen 32-Bit-Integerwert mit Vorzeichen in eine Bytespanne.

TryWriteBytes(Span<Byte>, Int64)

Konvertiert einen 64-Bit-Integerwert mit Vorzeichen in eine Bytespanne.

TryWriteBytes(Span<Byte>, Single)

Konvertiert einen Gleitkommawert mit einfacher Genauigkeit in eine Bytespanne.

TryWriteBytes(Span<Byte>, UInt128)

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen.

TryWriteBytes(Span<Byte>, UInt16)

Konvertiert einen 16-Bit-Integerwert ohne Vorzeichen in eine Bytespanne.

TryWriteBytes(Span<Byte>, UInt32)

Konvertiert einen 32-Bit-Integerwert ohne Vorzeichen in eine Bytespanne.

TryWriteBytes(Span<Byte>, UInt64)

Konvertiert einen 64-Bit-Integerwert ohne Vorzeichen in eine Bytespanne.

UInt16BitsToHalf(UInt16)

Konvertiert die angegebene 16-Bit-Ganzzahl ohne Vorzeichen in eine Gleitkommazahl mit halber Genauigkeit.

UInt32BitsToSingle(UInt32)

Konvertiert die angegebene 32-Bit-Ganzzahl ohne Vorzeichen in eine Gleitkommazahl mit einfacher Genauigkeit.

UInt64BitsToDouble(UInt64)

Konvertiert die angegebene 64-Bit-Ganzzahl ohne Vorzeichen in eine Gleitkommazahl mit doppelter Genauigkeit.

Gilt für:

Weitere Informationen