BitConverter BitConverter BitConverter BitConverter Class

Definition

Konvertiert Basisdatentypen in ein Bytearray und ein Bytearray in Basisdatentypen. Converts base data types to an array of bytes, and an array of bytes to base data types.

public ref class BitConverter abstract sealed
public static class BitConverter
type BitConverter = class
Public Class BitConverter
Vererbung
BitConverterBitConverterBitConverterBitConverter

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von mehreren BitConverter -Klassenmethoden.The following code example illustrates the use of several BitConverter class methods.

// 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
*/
' 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 Werttypen in ihrer grundlegenden Form, als eine Reihe von Bytes zu bearbeiten.The BitConverter class helps manipulate value types in their fundamental form, as a series of bytes. Ein Byte wird als eine 8-Bit-Ganzzahl ohne Vorzeichen definiert.A byte is defined as an 8-bit unsigned integer. Die BitConverter Klasse enthält statische Methoden für das jeweils den primitiven Typen konvertieren, und aus einem Array von Bytes an, wie in der folgende Tabelle veranschaulicht.The BitConverter class includes static methods to convert each of the primitive types to and from an array of bytes, as the following table illustrates.

TypType Byte-KonvertierungTo byte conversion Byte-KonvertierungFrom byte conversion
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

- oder - -or-

DoubleToInt64Bits(Double)
ToDouble

- oder - -or-

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

Bei Verwendung von BitConverter Methoden, um Round-Trip-Daten, stellen sicher, dass die GetBytes überladen und To Typ Methode geben Sie den gleichen Typ.If you use BitConverter methods to round-trip data, make sure that the GetBytes overload and the ToType method specify the same type. Wiederherstellen von ein Array, das durch Aufruf eine Ganzzahl mit Vorzeichen darstellt, wie im folgenden Beispiel wird veranschaulicht, die ToUInt32 Methode kann dazu führen, ein Wert, der sich vom Original unterscheidet.As the following example illustrates, restoring an array that represents a signed integer by calling the ToUInt32 method can result in a value that is different from the original. Weitere Informationen finden Sie im Eintrag arbeiten mit nicht-Dezimalzahl signiert und bitweise Werte im BCL-Teamblog.For more information, see the entry Working with Signed Non-Decimal and Bitwise Values in the BCL Team Blog.

using System;

public class Example
{
   public static void Main()
   {
      int value = -16;
      Byte[] bytes = BitConverter.GetBytes(value); 
      
      // Convert bytes back to Int32.
      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
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 Bytes im Array zurückgegeben werden, indem die GetBytes methodenüberladungen (sowie der Reihenfolge von Bits in die ganze Zahl, die vom der DoubleToInt64Bits -Methode und die Reihenfolge der Zeichenfolgen mit hexadezimal zurückgegebenes der ToString(Byte[]) Methode) davon abhängig, ob die Computerarchitektur ist little-Endian oder big-Endian.The order of bytes in the array returned by the GetBytes method overloads (as well as the order of bits in the integer returned by the DoubleToInt64Bits method and the order of hexadecimal strings returned by the ToString(Byte[]) method) depends on whether the computer architecture is little-endian or big-endian. Auf ähnliche Weise die Reihenfolge der Bytes im Array und zurückgegeben, indem die To IntegerValue Methoden und die ToChar Methode hängt davon ab, ob die Computerarchitektur little-Endian oder big-Endian-ist.Similarly, the order of bytes in the array and returned by the ToIntegerValue methods and the ToChar method depends on whether the computer architecture is little-endian or big-endian. Die Bytereihenfolge der Architektur wird angegeben, indem die IsLittleEndian -Eigenschaft, die gibt true in little-Endian-Systemen und false auf big-Endian-Systemen.The endianness of an architecture is indicated by the IsLittleEndian property, which returns true on little-endian systems and false on big-endian systems. In little-Endian-Systemen stehen die niederwertigen Bytes höherwertigen Bytes.On little-endian systems, lower-order bytes precede higher-order bytes. Big-Endian-System stehen höherwertigen Bytes niederwertigen Bytes.On big-endian system, higher-order bytes precede lower-order bytes. In der folgende Tabelle veranschaulicht den Unterschied in den Bytearrays, die aus die ganzen Zahl 1.234.567.890 (0x499602D2) übergeben, um die GetBytes(Int32) Methode.The following table illustrates the difference in the byte arrays that result from passing the integer 1,234,567,890 (0x499602D2) to the GetBytes(Int32) method. Die Bytes werden in der Reihenfolge von das Byte am Index 0 auf das Byte am Index 3 aufgeführt.The bytes are listed in order from the byte at index 0 to the byte at index 3.

Little-Endian-Little-endian D2-02-96-49D2-02-96-49
Big-endianBig-endian 49-96-02-D249-96-02-D2

Da der Rückgabewert von einigen Methoden auf die Systemarchitektur abhängig ist, sind mit Vorsicht Bytedaten außerhalb der Computergrenzen von zu übertragen:Because the return value of some methods depends on system architecture, be careful when transmitting byte data beyond machine boundaries:

  • Wenn alle Systeme senden und Empfangen von Daten in jedem Fall sind die gleiche Bytereihenfolge, hat nichts ausgeführt werden, auf die Daten werden.If all systems sending and receiving data are guaranteed to have the same endianness, nothing has be done to the data.

  • Wenn Systeme senden und Empfangen von Daten mit abweichender endiancharakteristik aufweisen können, senden Sie Daten in einer bestimmten Reihenfolge immer.If systems sending and receiving data can have different endianness, always transmit data in a particular order. Dies bedeutet, dass die Reihenfolge der Bytes im Array, dessen Reihenfolge umgekehrt werden, entweder vor dem Senden oder nach dem empfangen kann.This means that the order of bytes in the array may have to be reversed either before sending them or after receiving them. Eine allgemeine Konvention wird zum Übertragen von Daten in die Netzwerk-Bytereihenfolge (big-Endian-Reihenfolge).A common convention is to transmit data in network byte order (big-endian order). Im folgende Beispiel stellt eine Implementierung für das Senden eines ganzzahliger Werts in der Netzwerk-Bytereihenfolge.The following example provides an implementation for sending an integer value in network byte order.

    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
    
    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 senden und Empfangen von Daten können abweichender endiancharakteristik aufweisen und die Daten zur Übertragung von Ganzzahlen mit Vorzeichen besteht, rufen Sie die IPAddress.HostToNetworkOrder Methode, um die Daten in die Netzwerk-Bytereihenfolge konvertieren und die IPAddress.NetworkToHostOrder Methode, um sie in der erforderlichen Reihenfolge konvertieren durch den Empfänger.If systems sending and receiving data can have different endianness and the data to be transmitted consists of signed integers, call the IPAddress.HostToNetworkOrder method to convert the data to network byte order and the IPAddress.NetworkToHostOrder method to convert it to the order required by the recipient.

Felder

IsLittleEndian IsLittleEndian IsLittleEndian IsLittleEndian

Gibt die Bytereihenfolge (Endianwert) an, in der Daten in dieser Computerarchitektur gespeichert werden. Indicates the byte order ("endianness") in which data is stored in this computer architecture.

Methoden

DoubleToInt64Bits(Double) DoubleToInt64Bits(Double) DoubleToInt64Bits(Double) DoubleToInt64Bits(Double)

Konvertiert die angegebene Gleitkommazahl mit doppelter Genauigkeit in eine 64-Bit-Ganzzahl mit Vorzeichen. Converts the specified double-precision floating point number to a 64-bit signed integer.

GetBytes(Boolean) GetBytes(Boolean) GetBytes(Boolean) GetBytes(Boolean)

Gibt den angegebenen booleschen Wert als Bytearray zurück Returns the specified Boolean value as a byte array.

GetBytes(Char) GetBytes(Char) GetBytes(Char) GetBytes(Char)

Gibt den Wert des angegebenen Unicode-Zeichens als Bytearray zurück. Returns the specified Unicode character value as an array of bytes.

GetBytes(Double) GetBytes(Double) GetBytes(Double) GetBytes(Double)

Gibt den angegebenen Gleitkommawert mit doppelter Genauigkeit als Bytearray zurück. Returns the specified double-precision floating point value as an array of bytes.

GetBytes(Int16) GetBytes(Int16) GetBytes(Int16) GetBytes(Int16)

Gibt den Wert der angegebenen 16-Bit-Ganzzahl mit Vorzeichen als Bytearray zurück. Returns the specified 16-bit signed integer value as an array of bytes.

GetBytes(Int32) GetBytes(Int32) GetBytes(Int32) GetBytes(Int32)

Gibt den angegebenen ganzzahligen 32-Bit-Wert mit Vorzeichen als Bytearray zurück Returns the specified 32-bit signed integer value as an array of bytes.

GetBytes(Int64) GetBytes(Int64) GetBytes(Int64) GetBytes(Int64)

Gibt den angegebenen ganzzahligen 64-Bit-Wert mit Vorzeichen als Bytearray zurück. Returns the specified 64-bit signed integer value as an array of bytes.

GetBytes(Single) GetBytes(Single) GetBytes(Single) GetBytes(Single)

Gibt den angegebenen Gleitkommawert mit einfacher Genauigkeit als Bytearray zurück. Returns the specified single-precision floating point value as an array of bytes.

GetBytes(UInt16) GetBytes(UInt16) GetBytes(UInt16) GetBytes(UInt16)

Gibt den Wert der angegebenen vorzeichenlosen 16-Bit-Ganzzahl als Bytearray zurück. Returns the specified 16-bit unsigned integer value as an array of bytes.

GetBytes(UInt32) GetBytes(UInt32) GetBytes(UInt32) GetBytes(UInt32)

Gibt den Wert der angegebenen vorzeichenlosen 32-Bit-Ganzzahl als Bytearray zurück Returns the specified 32-bit unsigned integer value as an array of bytes.

GetBytes(UInt64) GetBytes(UInt64) GetBytes(UInt64) GetBytes(UInt64)

Gibt den Wert der angegebenen vorzeichenlosen 64-Bit-Ganzzahl als Bytearray zurück Returns the specified 64-bit unsigned integer value as an array of bytes.

Int32BitsToSingle(Int32) Int32BitsToSingle(Int32) Int32BitsToSingle(Int32) Int32BitsToSingle(Int32)
Int64BitsToDouble(Int64) Int64BitsToDouble(Int64) Int64BitsToDouble(Int64) Int64BitsToDouble(Int64)

Konvertiert die angegebene 64-Bit-Ganzzahl mit Vorzeichen in eine Gleitkommazahl mit doppelter Genauigkeit. Converts the specified 64-bit signed integer to a double-precision floating point number.

SingleToInt32Bits(Single) SingleToInt32Bits(Single) SingleToInt32Bits(Single) SingleToInt32Bits(Single)
ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>) ToBoolean(ReadOnlySpan<Byte>)
ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32) ToBoolean(Byte[], Int32)

Gibt einen booleschen Wert zurück, der aus dem Byte an der angegebenen Position eines Bytearrays konvertiert wurde Returns a Boolean value converted from the byte at a specified position in a byte array.

ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>) ToChar(ReadOnlySpan<Byte>)
ToChar(Byte[], Int32) ToChar(Byte[], Int32) ToChar(Byte[], Int32) ToChar(Byte[], Int32)

Gibt ein Unicode-Zeichen zurück, das aus zwei Bytes an der angegebenen Position in einem Bytearray konvertiert wurde. Returns a Unicode character converted from two bytes at a specified position in a byte array.

ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>) ToDouble(ReadOnlySpan<Byte>)
ToDouble(Byte[], Int32) ToDouble(Byte[], Int32) ToDouble(Byte[], Int32) ToDouble(Byte[], Int32)

Gibt eine Gleitkommazahl mit doppelter Genauigkeit zurück, die aus acht Bytes an der angegebenen Position in einem Bytearray konvertiert wurde. Returns a double-precision floating point number converted from eight bytes at a specified position in a byte array.

ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>) ToInt16(ReadOnlySpan<Byte>)
ToInt16(Byte[], Int32) ToInt16(Byte[], Int32) ToInt16(Byte[], Int32) 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. Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.

ToInt32(Byte[], Int32) ToInt32(Byte[], Int32) ToInt32(Byte[], Int32) 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. Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.

ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>) ToInt32(ReadOnlySpan<Byte>)
ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>) ToInt64(ReadOnlySpan<Byte>)
ToInt64(Byte[], Int32) ToInt64(Byte[], Int32) ToInt64(Byte[], Int32) 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. Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.

ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>) ToSingle(ReadOnlySpan<Byte>)
ToSingle(Byte[], Int32) ToSingle(Byte[], Int32) ToSingle(Byte[], Int32) ToSingle(Byte[], Int32)

Gibt eine Gleitkommazahl mit einfacher Genauigkeit zurück, die aus vier Bytes an der angegebenen Position in einem Bytearray konvertiert wurde. Returns a single-precision floating point number converted from four bytes at a specified position in a byte array.

ToString(Byte[]) ToString(Byte[]) ToString(Byte[]) ToString(Byte[])

Konvertiert den numerischen Wert jedes Elements im angegebenen Bytearray in die entsprechende hexadezimale Zeichenfolgendarstellung. Converts the numeric value of each element of a specified array of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32) ToString(Byte[], Int32) ToString(Byte[], Int32) ToString(Byte[], Int32)

Konvertiert den numerischen Wert jedes Elements in einem Teil des angegebenen Bytearrays in die entsprechende hexadezimale Zeichenfolgendarstellung. Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32) ToString(Byte[], Int32, Int32)

Konvertiert den numerischen Wert jedes Elements in einem Teil des angegebenen Bytearrays in die entsprechende hexadezimale Zeichenfolgendarstellung. Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>) ToUInt16(ReadOnlySpan<Byte>)
ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32) ToUInt16(Byte[], Int32)

Gibt eine vorzeichenlose 16-Bit-Ganzzahl zurück, die aus zwei Bytes an der angegebenen Position in einem Bytearray konvertiert wurde. Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>) ToUInt32(ReadOnlySpan<Byte>)
ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32) ToUInt32(Byte[], Int32)

Gibt eine vorzeichenlose 32-Bit-Ganzzahl zurück, die aus vier Bytes an der angegebenen Position in einem Bytearray konvertiert wurde. Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.

ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32) ToUInt64(Byte[], Int32)

Gibt eine vorzeichenlose 64-Bit-Ganzzahl zurück, die aus acht Bytes an der angegebenen Position in einem Bytearray konvertiert wurde. Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.

ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>) ToUInt64(ReadOnlySpan<Byte>)
TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean) TryWriteBytes(Span<Byte>, Boolean)
TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char) TryWriteBytes(Span<Byte>, Char)
TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double) TryWriteBytes(Span<Byte>, Double)
TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16) TryWriteBytes(Span<Byte>, Int16)
TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32) TryWriteBytes(Span<Byte>, Int32)
TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64) TryWriteBytes(Span<Byte>, Int64)
TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single) TryWriteBytes(Span<Byte>, Single)
TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16) TryWriteBytes(Span<Byte>, UInt16)
TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32) TryWriteBytes(Span<Byte>, UInt32)
TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64) TryWriteBytes(Span<Byte>, UInt64)

Gilt für:

Siehe auch