Byte Struktur

Definition

Stellt eine ganze 8-Bit-Zahl ohne Vorzeichen dar.

public value class System::Byte : IComparable, IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, IFormattable
public value class System::Byte : IComparable, IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, ISpanFormattable
public value class System::Byte : IComparable, IConvertible, IFormattable
public value class System::Byte : IComparable, IComparable<System::Byte>, IEquatable<System::Byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, ISpanFormattable
[System.Serializable]
public struct Byte : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IEquatable<byte>, IFormattable
type byte = struct
    interface IConvertible
    interface IFormattable
type byte = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type byte = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type byte = struct
    interface IFormattable
    interface IConvertible
type byte = struct
    interface IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IConvertible, IEquatable(Of Byte), IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IConvertible, IEquatable(Of Byte), ISpanFormattable
Public Structure Byte
Implements IComparable, IConvertible, IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IEquatable(Of Byte), IFormattable
Vererbung
Attribute
Implementiert

Hinweise

Byte ist ein unveränderlicher Werttyp, der ganze Zahlen ohne Vorzeichen mit Werten darstellt, die zwischen 0 (dargestellt durch die Byte.MinValue Konstante) und 255 (dargestellt durch die Byte.MaxValue Konstante) liegen. .NET enthält auch den 8-Bit-Ganzzahlwerttyp mit Vorzeichen SByte , der Werte zwischen -128 und 127 darstellt.

Instanziieren eines Bytewerts

Sie können einen Byte Wert auf verschiedene Weise instanziieren:

  • Sie können eine Variable deklarieren Byte und ihr einen ganzzahligen Literalwert zuweisen, der sich innerhalb des Bereichs des Byte Datentyps befindet. Im folgenden Beispiel werden zwei Variablen deklariert Byte und ihnen Werte auf diese Weise zugewiesen.

    byte value1 = 64;
    byte value2 = 255;
    
    Dim value1 As Byte = 64
    Dim value2 As Byte = 255
    
  • Sie können einem Byte einen numerischen Wert zuweisen, der kein Byte ist. Dies ist eine einschränkende Konvertierung, daher ist ein Umwandlungsoperator in C# und eine Konvertierungsmethode in Visual Basic erforderlich, wenn Option Strict eingeschaltet ist. Wenn der Nicht-Bytewert ein -, - oder -Wert ist, Single Double der eine Decimal Bruchkomponente enthält, hängt die Behandlung des Bruchteils davon ab, ob der Compiler die Konvertierung ausführt. Im folgenden Beispiel werden Variablen mehrere numerische Werte Byte zugewiesen.

    int int1 = 128;
    try {
       byte value1 = (byte) int1;
       Console.WriteLine(value1);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of a byte.", int1);
    }
    
    double dbl2 = 3.997;
    try {
       byte value2 = (byte) dbl2;
       Console.WriteLine(value2);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of a byte.", dbl2);
    }
    // The example displays the following output:
    //       128
    //       3
    
    Dim int1 As Integer = 128
    Try
       Dim value1 As Byte = CByte(int1)
       Console.WriteLine(value1)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of a byte.", int1)
    End Try
    
    Dim dbl2 As Double = 3.997
    Try
       Dim value2 As Byte = CByte(dbl2)
       Console.WriteLine(value2)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of a byte.", dbl2)
    End Try   
    ' The example displays the following output:
    '       128
    '       4
    
  • Sie können eine Methode der Convert -Klasse aufrufen, um jeden unterstützten Typ in einen Wert zu Byte konvertieren. Dies ist möglich, da Byte die IConvertible -Schnittstelle unterstützt. Das folgende Beispiel veranschaulicht die Konvertierung eines Arrays von Int32 Werten in Byte -Werte.

    int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
    byte result;
    foreach (int number in numbers)
    {
       try {
          result = Convert.ToByte(number);
          Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                            number.GetType().Name, number,
                            result.GetType().Name, result);
       }
       catch (OverflowException) {
          Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                            number.GetType().Name, number);
       }
    }
    // The example displays the following output:
    //       The Int32 value -2147483648 is outside the range of the Byte type.
    //       The Int32 value -1 is outside the range of the Byte type.
    //       Converted the Int32 value 0 to the Byte value 0.
    //       Converted the Int32 value 121 to the Byte value 121.
    //       The Int32 value 340 is outside the range of the Byte type.
    //       The Int32 value 2147483647 is outside the range of the Byte type.
    
    Dim numbers() As Integer = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue }
    Dim result As Byte
    For Each number As Integer In numbers
       Try
          result = Convert.ToByte(number)
          Console.WriteLIne("Converted the {0} value {1} to the {2} value {3}.", _
                            number.GetType().Name, number, _
                            result.GetType().Name, result)
       Catch e As OverflowException
          Console.WriteLine("The {0} value {1} is outside the range of the Byte type.", _
                            number.GetType().Name, number)
       End Try
    Next
    ' The example displays the following output:
    '       The Int32 value -2147483648 is outside the range of the Byte type.
    '       The Int32 value -1 is outside the range of the Byte type.
    '       Converted the Int32 value 0 to the Byte value 0.
    '       Converted the Int32 value 121 to the Byte value 121.
    '       The Int32 value 340 is outside the range of the Byte type.
    '       The Int32 value 2147483647 is outside the range of the Byte type.
    
  • Sie können die Parse - oder TryParse -Methode aufrufen, um die Zeichenfolgendarstellung eines Byte Werts in einen zu Byte konvertieren. Die Zeichenfolge kann dezimale oder hexadezimale Ziffern enthalten. Im folgenden Beispiel wird der Analysevorgang mithilfe einer Dezimal- und einer Hexadezimalzeichenfolge veranschaulicht.

    string string1 = "244";
    try {
       byte byte1 = Byte.Parse(string1);
       Console.WriteLine(byte1);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string1);
    }
    catch (FormatException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string1);
    }
    
    string string2 = "F9";
    try {
       byte byte2 = Byte.Parse(string2,
                               System.Globalization.NumberStyles.HexNumber);
       Console.WriteLine(byte2);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string2);
    }
    catch (FormatException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string2);
    }
    // The example displays the following output:
    //       244
    //       249
    
    Dim string1 As String = "244"
    Try
       Dim byte1 As Byte = Byte.Parse(string1)
       Console.WriteLine(byte1)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a byte.", string1)
    Catch e As FormatException
       Console.WriteLine("'{0}' is out of range of a byte.", string1)
    End Try
    
    Dim string2 As String = "F9"
    Try
       Dim byte2 As Byte = Byte.Parse(string2,
                                 System.Globalization.NumberStyles.HexNumber)
       Console.WriteLine(byte2)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a byte.", string2)
    Catch e As FormatException
       Console.WriteLine("'{0}' is out of range of a byte.", string2)
    End Try
    ' The example displays the following output:
    '       244
    '       249
    

Ausführen von Vorgängen für Bytewerte

Der Byte Typ unterstützt mathematische Standardoperationen wie Addition, Subtraktion, Division, Multiplikation, Subtraktion, Negation und unäre Negation. Wie die anderen ganzzahligen Typen unterstützt auch der Byte Typ die bitweisen AND Operatoren , , , left shift OR und right XOR shift.

Sie können die numerischen Standardoperatoren verwenden, um zwei Werte zu Byte vergleichen, oder Sie können die CompareTo - oder Equals -Methode aufrufen.

Sie können auch die Member der Math -Klasse aufrufen, um eine Vielzahl von numerischen Vorgängen auszuführen. Dazu gehören das Abrufen des absoluten Werts einer Zahl, das Berechnen des Quotienten und des Rests aus der integralen Division, das Bestimmen des Maximalen oder Minimalwerts von zwei ganzen Zahlen, das Abrufen des Vorzeichens einer Zahl und das Runden einer Zahl.

Darstellen eines Byte als Zeichenfolge

Der Byte -Typ bietet vollständige Unterstützung für standardmäßige und benutzerdefinierte numerische Formatzeichenfolgen. (Weitere Informationen finden Sie unter Formatierungstypen, numerische Standardformatzeichenfolgenund benutzerdefinierte numerische Formatzeichenfolgen.) In den meisten Fall werden Bytewerte jedoch als einstellige bis dreistellige Werte ohne zusätzliche Formatierung oder als zweistellige Hexadezimalwerte dargestellt.

Um einen Byte Wert als integrale Zeichenfolge ohne führende Nullen zu formatieren, können Sie die parameterlose ToString() Methode aufrufen. Mit dem Formatbezeichner "D" können Sie auch eine angegebene Anzahl führender Nullen in die Zeichenfolgendarstellung einschließen. Mit dem Formatbezeichner "X" können Sie einen Byte Wert als Hexadezimalzeichenfolge darstellen. Im folgenden Beispiel werden die Elemente in einem Array von Byte Werten auf diese drei Arten formatiert.

byte[] numbers = { 0, 16, 104, 213 };
foreach (byte number in numbers) {
   // Display value using default formatting.
   Console.Write("{0,-3}  -->   ", number.ToString());
   // Display value with 3 digits and leading zeros.
   Console.Write(number.ToString("D3") + "   ");
   // Display value with hexadecimal.
   Console.Write(number.ToString("X2") + "   ");
   // Display value with four hexadecimal digits.
   Console.WriteLine(number.ToString("X4"));
}
// The example displays the following output:
//       0    -->   000   00   0000
//       16   -->   016   10   0010
//       104  -->   104   68   0068
//       213  -->   213   D5   00D5
Dim numbers() As Byte = { 0, 16, 104, 213 }
For Each number As Byte In numbers
   ' Display value using default formatting.
   Console.Write("{0,-3}  -->   ", number.ToString())
   ' Display value with 3 digits and leading zeros.
   Console.Write(number.ToString("D3") + "   ")
   ' Display value with hexadecimal.
   Console.Write(number.ToString("X2") + "   ")
   ' Display value with four hexadecimal digits.
   Console.WriteLine(number.ToString("X4"))
Next   
' The example displays the following output:
'       0    -->   000   00   0000
'       16   -->   016   10   0010
'       104  -->   104   68   0068
'       213  -->   213   D5   00D5

Sie können einen Wert auch Byte als binäre, oktale, dezimale oder hexadezimale Zeichenfolge formatieren, indem Sie die -Methode aufrufen ToString(Byte, Int32) und die Basis als zweiten Parameter der Methode angeben. Das folgende Beispiel ruft diese Methode auf, um die binären, oktalen und hexadezimalen Darstellungen eines Arrays von Bytewerten anzuzeigen.

byte[] numbers ={ 0, 16, 104, 213 };
Console.WriteLine("{0}   {1,8}   {2,5}   {3,5}",
                  "Value", "Binary", "Octal", "Hex");
foreach (byte number in numbers) {
   Console.WriteLine("{0,5}   {1,8}   {2,5}   {3,5}",
                     number, Convert.ToString(number, 2),
                     Convert.ToString(number, 8),
                     Convert.ToString(number, 16));
}
// The example displays the following output:
//       Value     Binary   Octal     Hex
//           0          0       0       0
//          16      10000      20      10
//         104    1101000     150      68
//         213   11010101     325      d5
Dim numbers() As Byte = { 0, 16, 104, 213 }
Console.WriteLine("{0}   {1,8}   {2,5}   {3,5}", _
                  "Value", "Binary", "Octal", "Hex")
For Each number As Byte In numbers
   Console.WriteLine("{0,5}   {1,8}   {2,5}   {3,5}", _
                     number, Convert.ToString(number, 2), _
                     Convert.ToString(number, 8), _
                     Convert.ToString(number, 16))
Next      
' The example displays the following output:
'       Value     Binary   Octal     Hex
'           0          0       0       0
'          16      10000      20      10
'         104    1101000     150      68
'         213   11010101     325      d5

Arbeiten mit nicht dezimalen Bytewerten

Zusätzlich zur Arbeit mit einzelnen Bytes als Dezimalwerte können Sie bitweise Vorgänge mit Bytewerten ausführen oder mit Bytearrays oder mit den binären oder hexadezimalen Darstellungen von Bytewerten arbeiten. Beispielsweise können Überladungen der BitConverter.GetBytes -Methode jeden der primitiven Datentypen in ein Bytearray konvertieren, und die BigInteger.ToByteArray -Methode konvertiert einen BigInteger Wert in ein Bytearray.

Byte -Werte werden nur nach ihrer Größe ohne Vorzeichenbit in 8 Bits dargestellt. Dies ist wichtig, wenn Sie bitweise Vorgänge für Werte ausführen Byte oder wenn Sie mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder Vergleichsvorgang für zwei beliebige Nicht-Dezimalwerte auszuführen, müssen beide Werte dieselbe Darstellung verwenden.

Wenn ein Vorgang für zwei Werte ausgeführt Byte wird, teilen sich die Werte die gleiche Darstellung, sodass das Ergebnis genau ist. Dies wird im folgenden Beispiel veranschaulicht, in dem das kleinstmögliche Bit eines Werts maskiert Byte wird, um sicherzustellen, dass es gerade ist.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { Convert.ToString(12, 16),
                          Convert.ToString(123, 16),
                          Convert.ToString(245, 16) };

      byte mask = 0xFE;
      foreach (string value in values) {
         Byte byteValue = Byte.Parse(value, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("{0} And {1} = {2}", byteValue, mask,
                           byteValue & mask);
      }
   }
}
// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { Convert.ToString(12, 16), _
                                 Convert.ToString(123, 16), _
                                 Convert.ToString(245, 16) }
      
      Dim mask As Byte = &hFE
      For Each value As String In values
         Dim byteValue As Byte = Byte.Parse(value, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("{0} And {1} = {2}", byteValue, mask, _ 
                           byteValue And mask)
      Next         
   End Sub
End Module
' The example displays the following output:
'       12 And 254 = 12
'       123 And 254 = 122
'       245 And 254 = 244

Wenn Sie jedoch sowohl mit Bits ohne Vorzeichen als auch mit Vorzeichen arbeiten, werden bitweise Vorgänge durch die Tatsache kompliziert, dass die Werte die SByte Vorzeichen- und Größendarstellung für positive Werte und die Komplementdarstellung von zwei für negative Werte verwenden. Um eine sinnvolle bitweise Operation auszuführen, müssen die Werte in zwei äquivalente Darstellungen konvertiert werden, und Informationen zum Vorzeichenbit müssen beibehalten werden. Im folgenden Beispiel werden die Bits 2 und 4 eines Arrays aus 8-Bit-Werten mit Vorzeichen und ohne Vorzeichen maskiert.

using System;
using System.Collections.Generic;
using System.Globalization;

public struct ByteString
{
   public string Value;
   public int Sign;
}

public class Example
{
   public static void Main()
   {
      ByteString[] values = CreateArray(-15, 123, 245);

      byte mask = 0x14;        // Mask all bits but 2 and 4.

      foreach (ByteString strValue in values) {
         byte byteValue = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("{0} ({1}) And {2} ({3}) = {4} ({5})",
                           strValue.Sign * byteValue,
                           Convert.ToString(byteValue, 2),
                           mask, Convert.ToString(mask, 2),
                           (strValue.Sign & Math.Sign(mask)) * (byteValue & mask),
                           Convert.ToString(byteValue & mask, 2));
      }
   }

   private static ByteString[] CreateArray(params int[] values)
   {
      List<ByteString> byteStrings = new List<ByteString>();

      foreach (object value in values) {
         ByteString temp = new ByteString();
         int sign = Math.Sign((int) value);
         temp.Sign = sign;

         // Change two's complement to magnitude-only representation.
         temp.Value = Convert.ToString(((int) value) * sign, 16);

         byteStrings.Add(temp);
      }
      return byteStrings.ToArray();
   }
}
// The example displays the following output:
//       -15 (1111) And 20 (10100) = 4 (100)
//       123 (1111011) And 20 (10100) = 16 (10000)
//       245 (11110101) And 20 (10100) = 20 (10100)
Imports System.Collections.Generic
Imports System.Globalization

Public Structure ByteString
   Public Value As String
   Public Sign As Integer
End Structure

Module Example
   Public Sub Main()
      Dim values() As ByteString = CreateArray(-15, 123, 245)
      
      Dim mask As Byte = &h14        ' Mask all bits but 2 and 4.
      
      For Each strValue As ByteString In values
         Dim byteValue As Byte = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("{0} ({1}) And {2} ({3}) = {4} ({5})", _ 
                           strValue.Sign * byteValue, _ 
                           Convert.ToString(byteValue, 2), _
                           mask, Convert.ToString(mask, 2), _
                           (strValue.Sign And Math.Sign(mask)) * (byteValue And mask), _
                           Convert.ToString(byteValue And mask, 2))
      Next         
   End Sub
   
   Private Function CreateArray(ParamArray values() As Object) As ByteString()
      Dim byteStrings As New List(Of ByteString)
      For Each value As Object In values
         Dim temp As New ByteString()
         Dim sign As Integer = Math.Sign(value)
         temp.Sign = sign
         ' Change two's complement to magnitude-only representation.
         value = value * sign

         temp.Value = Convert.ToString(value, 16)
         byteStrings.Add(temp)
      Next
      Return byteStrings.ToArray()
   End Function   
End Module
' The example displays the following output:
'       -15 (1111) And 20 (10100) = 4 (100)
'       123 (1111011) And 20 (10100) = 16 (10000)
'       245 (11110101) And 20 (10100) = 20 (10100)

Felder

MaxValue

Stellt den größtmöglichen Wert von Byte dar. Dieses Feld ist konstant.

MinValue

Stellt den kleinstmöglichen Wert von Byte dar. Dieses Feld ist konstant.

Methoden

CompareTo(Byte)

Vergleicht diese Instanz mit einer angegebenen 8-Bit-Ganzzahl ohne Vorzeichen, und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.

Equals(Byte)

Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Byte-Objekt den gleichen Wert darstellen.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

GetTypeCode()

Gibt den TypeCode für den Werttyp Byte zurück.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte.

Parse(String)

Wandelt die angegebene Zeichenfolgendarstellung einer Zahl in ihre Byte-Entsprechung um.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die Byte-Entsprechung.

Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die Byte-Entsprechung.

Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte.

ToString()

Konvertiert den Wert des aktuellen Byte-Objekts in die entsprechende Zeichenfolgendarstellung.

ToString(IFormatProvider)

Konvertiert den numerischen Wert des aktuellen Byte-Objekts unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

ToString(String)

Konvertiert den Wert des aktuellen Byte-Objekts unter Verwendung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.

ToString(String, IFormatProvider)

Konvertiert den Wert des aktuellen Byte-Objekts unter Verwendung des angegebenen Formats sowie der kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen Instanz einer ganzen 8-Bit-Zahl ohne Vorzeichen in die angegebene Zeichenspanne zu formatieren

TryParse(ReadOnlySpan<Char>, Byte)

Versucht, die Spannendarstellung einer Zahl in deren Byte-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)

Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

TryParse(String, Byte)

Versucht, die Zeichenfolgendarstellung einer Zahl in deren Byte-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

TryParse(String, NumberStyles, IFormatProvider, Byte)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)

Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.

IConvertible.GetTypeCode()

Gibt den TypeCode für diese Instanz zurück.

IConvertible.ToBoolean(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.

IConvertible.ToDecimal(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).

Gilt für

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die den Instanzzustand zu ändern scheinen, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um threadsicherheit zu gewährleisten.

Siehe auch