BitConverter Klasse
Definition
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
-
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 ist als 8-Bit-Ganzzahl ohne Vorzeichen definiert. Die BitConverter -Klasse enthält statische Methoden, um jeden der primitiven Typen in und aus einem Bytearray zu konvertieren, wie die folgende 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 zum Roundtrip von Daten verwenden BitConverter , stellen Sie sicher, dass die GetBytes Überladung und die To
Type-Methode denselben Typ angeben. Wie das folgende Beispiel veranschaulicht, kann das Wiederherstellen eines Arrays, das eine ganzzahlige Vorzeichen darstellt, durch Aufrufen der ToUInt32 Methode zu einem anderen Wert als dem ursprünglichen führen. Weitere Informationen finden Sie unter Arbeiten mit nicht dezimalen und bitweisen Vorzeichenwerten.
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 Bytes im Array, die von den GetBytes Methodenüberladungen zurückgegeben wird (sowie die Reihenfolge der Bits in der von der DoubleToInt64Bits Methode zurückgegebenen ganzzahligen Zahl) hängt davon ab, ob die Computerarchitektur Little-Endian oder Big-Endian ist. In ähnlicher Weise hängt die Reihenfolge der Bytes im Array, die von den To
IntegerValue-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-End-Systemen zurückgibttrue
. Auf Little-Endian-Systemen gehen Bytes niedrigerer Reihenfolge vor Bytes höherer Ordnung vor. Im Big-End-System gehen Bytes höherer Reihenfolge vor Den Bytes niedrigerer Reihenfolge. Die folgende Tabelle veranschaulicht den Unterschied in den Bytearrays, die sich aus der Übergabe der ganzen Zahl 1.234.567.890 (0x499602D2) an die GetBytes(Int32) -Methode ergeben. 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 beim Übertragen von Bytedaten über Computergrenzen hinaus vorsichtig sein:
Wenn für alle Systeme, die Daten senden und empfangen, die gleiche Endianität garantiert sind, muss nichts mit den Daten getan werden.
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 entweder vor dem Senden oder nach dem Empfang umgekehrt werden muss. Eine gängige Konvention besteht darin, Daten in Netzwerkbytereihenfolge (Big-Endian-Reihenfolge) zu übertragen. Das folgende Beispiel bietet eine Implementierung zum Senden eines ganzzahligen Werts in Netzwerkbytereihenfolge.
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 und die IPAddress.NetworkToHostOrder -Methode zu konvertieren, 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 ganzzahligen 16-Bit-Wert 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 einzeler 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 halber Genauigkeit 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 einzeler 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 einzeler 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 einzeler Genauigkeit. |
UInt64BitsToDouble(UInt64) |
Konvertiert die angegebene 64-Bit-Ganzzahl ohne Vorzeichen in eine Gleitkommazahl mit doppelter Genauigkeit. |
Gilt für:
Weitere Informationen
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für