Byte Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

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

public value class System::Byte : IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, IParsable<System::Byte>, ISpanParsable<System::Byte>, System::Numerics::IAdditionOperators<System::Byte, System::Byte, System::Byte>, System::Numerics::IAdditiveIdentity<System::Byte, System::Byte>, System::Numerics::IBinaryInteger<System::Byte>, System::Numerics::IBinaryNumber<System::Byte>, System::Numerics::IBitwiseOperators<System::Byte, System::Byte, System::Byte>, System::Numerics::IComparisonOperators<System::Byte, System::Byte, bool>, System::Numerics::IDecrementOperators<System::Byte>, System::Numerics::IDivisionOperators<System::Byte, System::Byte, System::Byte>, System::Numerics::IEqualityOperators<System::Byte, System::Byte, bool>, System::Numerics::IIncrementOperators<System::Byte>, System::Numerics::IMinMaxValue<System::Byte>, System::Numerics::IModulusOperators<System::Byte, System::Byte, System::Byte>, System::Numerics::IMultiplicativeIdentity<System::Byte, System::Byte>, System::Numerics::IMultiplyOperators<System::Byte, System::Byte, System::Byte>, System::Numerics::INumber<System::Byte>, System::Numerics::INumberBase<System::Byte>, System::Numerics::IShiftOperators<System::Byte, int, System::Byte>, System::Numerics::ISubtractionOperators<System::Byte, System::Byte, System::Byte>, System::Numerics::IUnaryNegationOperators<System::Byte, System::Byte>, System::Numerics::IUnaryPlusOperators<System::Byte, System::Byte>, System::Numerics::IUnsignedNumber<System::Byte>

public readonly struct Byte : IComparable<byte>, IConvertible, IEquatable<byte>, IParsable<byte>, ISpanParsable<byte>, System.Numerics.IAdditionOperators<byte,byte,byte>, System.Numerics.IAdditiveIdentity<byte,byte>, System.Numerics.IBinaryInteger<byte>, System.Numerics.IBinaryNumber<byte>, System.Numerics.IBitwiseOperators<byte,byte,byte>, System.Numerics.IComparisonOperators<byte,byte,bool>, System.Numerics.IDecrementOperators<byte>, System.Numerics.IDivisionOperators<byte,byte,byte>, System.Numerics.IEqualityOperators<byte,byte,bool>, System.Numerics.IIncrementOperators<byte>, System.Numerics.IMinMaxValue<byte>, System.Numerics.IModulusOperators<byte,byte,byte>, System.Numerics.IMultiplicativeIdentity<byte,byte>, System.Numerics.IMultiplyOperators<byte,byte,byte>, System.Numerics.INumber<byte>, System.Numerics.INumberBase<byte>, System.Numerics.IShiftOperators<byte,int,byte>, System.Numerics.ISubtractionOperators<byte,byte,byte>, System.Numerics.IUnaryNegationOperators<byte,byte>, System.Numerics.IUnaryPlusOperators<byte,byte>, System.Numerics.IUnsignedNumber<byte>

type byte = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<byte>
    interface ISpanFormattable
    interface ISpanParsable<byte>
    interface IAdditionOperators<byte, byte, byte>
    interface IAdditiveIdentity<byte, byte>
    interface IBinaryInteger<byte>
    interface IBinaryNumber<byte>
    interface IBitwiseOperators<byte, byte, byte>
    interface IComparisonOperators<byte, byte, bool>
    interface IEqualityOperators<byte, byte, bool>
    interface IDecrementOperators<byte>
    interface IDivisionOperators<byte, byte, byte>
    interface IIncrementOperators<byte>
    interface IModulusOperators<byte, byte, byte>
    interface IMultiplicativeIdentity<byte, byte>
    interface IMultiplyOperators<byte, byte, byte>
    interface INumber<byte>
    interface INumberBase<byte>
    interface ISubtractionOperators<byte, byte, byte>
    interface IUnaryNegationOperators<byte, byte>
    interface IUnaryPlusOperators<byte, byte>
    interface IShiftOperators<byte, int, byte>
    interface IMinMaxValue<byte>
    interface IUnsignedNumber<byte>

Public Structure Byte
Implements IAdditionOperators(Of Byte, Byte, Byte), IAdditiveIdentity(Of Byte, Byte), IBinaryInteger(Of Byte), IBinaryNumber(Of Byte), IBitwiseOperators(Of Byte, Byte, Byte), IComparable(Of Byte), IComparisonOperators(Of Byte, Byte, Boolean), IConvertible, IDecrementOperators(Of Byte), IDivisionOperators(Of Byte, Byte, Byte), IEqualityOperators(Of Byte, Byte, Boolean), IEquatable(Of Byte), IIncrementOperators(Of Byte), IMinMaxValue(Of Byte), IModulusOperators(Of Byte, Byte, Byte), IMultiplicativeIdentity(Of Byte, Byte), IMultiplyOperators(Of Byte, Byte, Byte), INumber(Of Byte), INumberBase(Of Byte), IParsable(Of Byte), IShiftOperators(Of Byte, Integer, Byte), ISpanParsable(Of Byte), ISubtractionOperators(Of Byte, Byte, Byte), IUnaryNegationOperators(Of Byte, Byte), IUnaryPlusOperators(Of Byte, Byte), IUnsignedNumber(Of Byte)

Vererbung

Object

ValueType

Byte

Implementiert

IComparable IComparable<Byte> IConvertible IEquatable<Byte> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Byte> IParsable<TSelf> ISpanParsable<Byte> ISpanParsable<TSelf> IAdditionOperators<Byte,Byte,Byte> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Byte,Byte> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<Byte> IBinaryNumber<Byte> IBinaryNumber<TSelf> IBitwiseOperators<Byte,Byte,Byte> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Byte,Byte,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Byte> IDecrementOperators<TSelf> IDivisionOperators<Byte,Byte,Byte> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Byte,Byte,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<Byte> IIncrementOperators<TSelf> IMinMaxValue<Byte> IModulusOperators<Byte,Byte,Byte> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Byte,Byte> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Byte,Byte,Byte> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Byte> INumber<TSelf> INumberBase<Byte> INumberBase<TSelf> IShiftOperators<Byte,Int32,Byte> IShiftOperators<TSelf,Int32,TSelf> ISubtractionOperators<Byte,Byte,Byte> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Byte,Byte> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Byte,Byte> IUnaryPlusOperators<TSelf,TSelf> IUnsignedNumber<Byte>

Hinweise

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

Instanziieren eines Bytewerts

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

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

  byte value1 = 64;
  byte value2 = 255;
  

  let value1 = 64uy
  let value2 = 255uy
  

  Dim value1 As Byte = 64
  Dim value2 As Byte = 255
  

• Sie können einem Byte einen numerischen Wert ohne Byte zuweisen. Dies ist eine einschränkende Konvertierung, sodass ein Umwandlungsoperator in C# und F# oder eine Konvertierungsmethode in Visual Basic erforderlich ist, wenn Option Strict aktiviert ist. Wenn der Nicht-Bytewert ein Single- , Double- oder Decimal -Wert ist, der eine Bruchkomponente enthält, hängt die Behandlung des Bruchteils davon ab, dass der Compiler die Konvertierung ausführt. Im folgenden Beispiel werden Variablen mehrere numerische Werte zugewiesen Byte .

  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
  

  let int1 = 128
  try
      let value1 = byte int1
      printfn $"{value1}"
  with :? OverflowException ->
      printfn $"{int1} is out of range of a byte."
  
  let dbl2 = 3.997
  try
      let value2 = byte dbl2
      printfn $"{value2}"
  with :? OverflowException ->
      printfn $"{dbl2} is out of range of a byte."
  
  // 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 Byte Wert zu konvertieren. Dies ist möglich, da Byte die IConvertible Schnittstelle unterstützt wird. 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.
  

  open System
  
  let numbers = [| Int32.MinValue; -1; 0; 121; 340; Int32.MaxValue |]
  
  for number in numbers do
      try
          let result = Convert.ToByte number
          printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
  
      with :? OverflowException ->
          printfn $"The {number.GetType().Name} value {number} is outside the range of the Byte type."
  
  
  // 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 -Methode oder TryParse aufrufen, um die Zeichenfolgendarstellung eines Byte Werts in einen Bytezu konvertieren. Die Zeichenfolge kann dezimale oder hexadezimale Ziffern enthalten. Im folgenden Beispiel wird der Analysevorgang veranschaulicht, indem sowohl eine dezimale als auch eine hexadezimale Zeichenfolge verwendet wird.

  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
  

  let string1 = "244"
  try
      let byte1 = Byte.Parse string1
      printfn $"{byte1}" 
  with
  | :? OverflowException ->
      printfn $"'{string1}' is out of range of a byte."
  | :? FormatException ->
      printfn $"'{string1}' is out of range of a byte."
  
  let string2 = "F9"
  try
      let byte2 = Byte.Parse(string2, System.Globalization.NumberStyles.HexNumber)
      printfn $"{byte2}"
  with
  | :? OverflowException ->
      printfn $"'{string2}' is out of range of a byte."
  | :? FormatException ->
      printfn $"'{string2}' is out of range of a byte."
  
  // 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 Standardvorgänge wie Addition, Subtraktion, Division, Multiplikation, Subtraktion, Negation und unäre Negation. Wie die anderen integralen Typen unterstützt der Byte Typ auch die bitweisen ANDOperatoren , OR, , XORlinks und rechts.

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

Sie können auch die Member der Math -Klasse aufrufen, um einen weiten Bereich von numerischen Vorgängen auszuführen, einschließlich des Abrufens des absoluten Werts einer Zahl, berechnen des Quotienten und Rests aus der integralen Division, Bestimmen des Maximalen oder Mindestwerts von zwei ganzen Zahlen, Abrufen des Vorzeichens einer Zahl und 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 Standardformatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.) Am häufigsten 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 hexadezimale Zeichenfolge 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

let numbers = [| 0; 16; 104; 213 |]
for number in numbers do
    // Display value using default formatting.
    number.ToString()
    |> printf "%-3s  -->   "

    // Display value with 3 digits and leading zeros.
    number.ToString "D3"
    |> printf "%s   "
    
    // Display value with hexadecimal.
    number.ToString "X2"
    |> printf "%s   "
    
    // Display value with four hexadecimal digits.
    number.ToString "X4"
    |> printfn "%s"

// 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 Byte Wert auch als binäre, oktale, dezimale oder hexadezimale Zeichenfolge formatieren, indem Sie die ToString(Byte, Int32) -Methode aufrufen und die Basis als zweiten Parameter der Methode angeben. Im folgenden Beispiel wird diese Methode aufgerufen, 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

let numbers = [| 0; 16; 104; 213 |]
printfn "%s   %8s   %5s   %5s" "Value" "Binary" "Octal" "Hex"
for number in numbers do
    printfn $"%5i{number}   %8s{Convert.ToString(number, 2)}   %5s{Convert.ToString(number, 8)}   %5s{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-Dezimalbytewerten

Zusätzlich zur Arbeit mit einzelnen Bytes als Dezimalwerte können Sie bitweise Vorgänge mit Bytewerten ausführen oder mit Bytearrays oder mit 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 in 8 Bits nur durch ihre Größe ohne Vorzeichenbit dargestellt. Dies ist wichtig zu beachten, wenn Sie bitweise Vorgänge für Byte Werte ausführen oder mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder vergleichsvorgang für zwei beliebige Nichtdezimalwerte auszuführen, müssen beide Werte dieselbe Darstellung verwenden.

Wenn ein Vorgang für zwei Byte Werte ausgeführt wird, teilen sich die Werte dieselbe Darstellung, sodass das Ergebnis genau ist. Dies wird im folgenden Beispiel veranschaulicht, das das bit der niedrigsten Reihenfolge eines Byte Werts maskiert, 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

open System
open System.Globalization

let values = 
    [ Convert.ToString(12, 16)
      Convert.ToString(123, 16)
      Convert.ToString(245, 16) ]

let mask = 0xFEuy
for value in values do
    let byteValue = Byte.Parse(value, NumberStyles.AllowHexSpecifier)
    printfn $"{byteValue} And {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 hingegen sowohl mit nicht signierten als auch mit vorzeichenierten Bits arbeiten, werden bitweise Vorgänge durch die Tatsache kompliziert, dass die SByte Werte die Darstellung von Zeichen und Größe für positive Werte und die Komplementdarstellung von zwei für negative Werte verwenden. Um einen aussagekräftigen bitweisen Vorgang auszuführen, müssen die Werte in zwei gleichwertige Darstellungen konvertiert werden, und Informationen zum Zeichenbit müssen beibehalten werden. Im folgenden Beispiel werden die Bits 2 und 4 eines Arrays mit signierten und unsignierten 8-Bit-Werten 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)

open System
open System.Collections.Generic
open System.Globalization

[<Struct>]
type ByteString =
    { Sign: int
      Value: string }

let createArray values =
    [ for value in values do
        let sign = sign value
        { Sign = sign
         // Change two's complement to magnitude-only representation.
          Value = Convert.ToString(value * sign, 16)} ]


let values = createArray [ -15; 123; 245 ]

let mask = 0x14uy        // Mask all bits but 2 and 4.

for strValue in values do
    let byteValue = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier)
    printfn $"{strValue.Sign * int byteValue} ({Convert.ToString(byteValue, 2)}) And {mask} ({Convert.ToString(mask, 2)}) = {(strValue.Sign &&& (int mask |> sign)) * int (byteValue &&& mask)} ({Convert.ToString(byteValue &&& mask, 2)})"

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

Clamp(Byte, Byte, Byte)	Klemmt einen Wert auf einen inklusiven Minimal- und Maximalwert.
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.
CreateChecked<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt einen instance des aktuellen Typs aus einem Wert, der alle Werte überlastt, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
DivRem(Byte, Byte)	Berechnet den Quotienten und den Rest von zwei Werten.
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.
IsEvenInteger(Byte)	Bestimmt, ob ein Wert eine gerade Integralzahl darstellt.
IsOddInteger(Byte)	Bestimmt, ob ein Wert eine ungerade Integralzahl darstellt.
IsPow2(Byte)	Bestimmt, ob ein Wert eine Macht von zwei ist.
LeadingZeroCount(Byte)	Berechnet die Anzahl der führenden Nullen in einem Wert.
Log2(Byte)	Berechnet das protokoll2 eines Werts.
Max(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
Min(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
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.
PopCount(Byte)	Berechnet die Anzahl der Bits, die in einem Wert festgelegt sind.
RotateLeft(Byte, Int32)	Rotiert einen Wert, der um einen bestimmten Betrag verlassen wird.
RotateRight(Byte, Int32)	Rotiert einen Wert nach rechts um einen bestimmten Betrag.
Sign(Byte)	Berechnet das Vorzeichen eines Werts.
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.
TrailingZeroCount(Byte)	Berechnet die Anzahl der nachfolgenden Nullen in einem Wert.
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>, IFormatProvider, Byte)	Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.
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, IFormatProvider, Byte)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
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

IAdditionOperators<Byte,Byte,Byte>.Addition(Byte, Byte)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditionOperators<Byte,Byte,Byte>.CheckedAddition(Byte, Byte)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditiveIdentity<Byte,Byte>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryInteger<Byte>.GetByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32)geschrieben werden.
IBinaryInteger<Byte>.GetShortestBitLength()	Ruft die Länge der Komplementdarstellung des aktuellen Werts in Bits ab.
IBinaryInteger<Byte>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Byte)	Stellt eine ganze 8-Bit-Zahl ohne Vorzeichen dar.
IBinaryInteger<Byte>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Byte)	Stellt eine ganze 8-Bit-Zahl ohne Vorzeichen dar.
IBinaryInteger<Byte>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-End-Format in eine bestimmte Spanne zu schreiben.
IBinaryInteger<Byte>.TryWriteLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IBinaryNumber<Byte>.AllBitsSet	Ruft eine instance des Binärtyps ab, in dem alle Bits festgelegt sind.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseAnd(Byte, Byte)	Berechnet den bitweisen und von zwei Werten.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseOr(Byte, Byte)	Berechnet den bitweisen oder von zwei Werten.
IBitwiseOperators<Byte,Byte,Byte>.ExclusiveOr(Byte, Byte)	Berechnet den exklusiven oder von zwei Werten.
IBitwiseOperators<Byte,Byte,Byte>.OnesComplement(Byte)	Berechnet die Eins-Komplement-Darstellung eines bestimmten Werts.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThan(Byte, Byte)	Vergleicht zwei Werte, um zu ermitteln, welcher größer ist.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThanOrEqual(Byte, Byte)	Vergleicht zwei Werte, um zu bestimmen, welche größer oder gleich sind.
IComparisonOperators<Byte,Byte,Boolean>.LessThan(Byte, Byte)	Vergleicht zwei Werte, um zu ermitteln, welcher kleiner ist.
IComparisonOperators<Byte,Byte,Boolean>.LessThanOrEqual(Byte, Byte)	Vergleicht zwei Werte, um zu bestimmen, welche kleiner oder gleich sind.
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).
IDecrementOperators<Byte>.CheckedDecrement(Byte)	Dekrementiert einen Wert.
IDecrementOperators<Byte>.Decrement(Byte)	Dekrementiert einen Wert.
IDivisionOperators<Byte,Byte,Byte>.Division(Byte, Byte)	Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.
IEqualityOperators<Byte,Byte,Boolean>.Equality(Byte, Byte)	Vergleicht zwei Werte, um die Gleichheit zu ermitteln.
IEqualityOperators<Byte,Byte,Boolean>.Inequality(Byte, Byte)	Vergleicht zwei Werte, um Ungleichheit zu ermitteln.
IIncrementOperators<Byte>.CheckedIncrement(Byte)	Erhöht einen Wert.
IIncrementOperators<Byte>.Increment(Byte)	Erhöht einen Wert.
IMinMaxValue<Byte>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<Byte>.MinValue	Ruft den Mindestwert des aktuellen Typs ab.
IModulusOperators<Byte,Byte,Byte>.Modulus(Byte, Byte)	Teilt zwei Werte zusammen, um deren Modul oder Rest zu berechnen.
IMultiplicativeIdentity<Byte,Byte>.MultiplicativeIdentity	Ruft die multiplikative Identität des aktuellen Typs ab.
IMultiplyOperators<Byte,Byte,Byte>.CheckedMultiply(Byte, Byte)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
IMultiplyOperators<Byte,Byte,Byte>.Multiply(Byte, Byte)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
INumber<Byte>.CopySign(Byte, Byte)	Kopiert das Zeichen eines Werts in das Zeichen eines anderen Werts.
INumber<Byte>.MaxNumber(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumber<Byte>.MinNumber(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Byte>.Abs(Byte)	Berechnet das Absolute eines Werts.
INumberBase<Byte>.IsCanonical(Byte)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<Byte>.IsComplexNumber(Byte)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<Byte>.IsFinite(Byte)	Bestimmt, ob ein Wert endlich ist.
INumberBase<Byte>.IsImaginaryNumber(Byte)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<Byte>.IsInfinity(Byte)	Bestimmt, ob ein Wert unendlich ist.
INumberBase<Byte>.IsInteger(Byte)	Bestimmt, ob ein Wert eine integrale Zahl darstellt.
INumberBase<Byte>.IsNaN(Byte)	Bestimmt, ob ein Wert NaN ist.
INumberBase<Byte>.IsNegative(Byte)	Bestimmt, ob ein Wert negativ ist.
INumberBase<Byte>.IsNegativeInfinity(Byte)	Bestimmt, ob ein Wert negativ unendlich ist.
INumberBase<Byte>.IsNormal(Byte)	Bestimmt, ob ein Wert normal ist.
INumberBase<Byte>.IsPositive(Byte)	Bestimmt, ob ein Wert positiv ist.
INumberBase<Byte>.IsPositiveInfinity(Byte)	Bestimmt, ob ein Wert positiv unendlich ist.
INumberBase<Byte>.IsRealNumber(Byte)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
INumberBase<Byte>.IsSubnormal(Byte)	Bestimmt, ob ein Wert subnormal ist.
INumberBase<Byte>.IsZero(Byte)	Bestimmt, ob ein Wert 0 ist.
INumberBase<Byte>.MaxMagnitude(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
INumberBase<Byte>.MaxMagnitudeNumber(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die die größere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Byte>.MinMagnitude(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
INumberBase<Byte>.MinMagnitudeNumber(Byte, Byte)	Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Byte>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<Byte>.Radix	Ruft die Basis für den Typ ab.
INumberBase<Byte>.TryConvertFromChecked<TOther>(TOther, Byte)	Stellt eine ganze 8-Bit-Zahl ohne Vorzeichen dar.
INumberBase<Byte>.TryConvertFromSaturating<TOther>(TOther, Byte)	Stellt eine ganze 8-Bit-Zahl ohne Vorzeichen dar.
INumberBase<Byte>.TryConvertFromTruncating<TOther>(TOther, Byte)	Stellt eine ganze 8-Bit-Zahl ohne Vorzeichen dar.
INumberBase<Byte>.TryConvertToChecked<TOther>(Byte, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Byte>.TryConvertToSaturating<TOther>(Byte, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren und dabei alle Werte zu überlasten, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Byte>.TryConvertToTruncating<TOther>(Byte, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Byte>.Zero	Ruft den Wert 0 für den Typ ab.
IShiftOperators<Byte,Int32,Byte>.LeftShift(Byte, Int32)	Verschiebt einen Wert, der von einem bestimmten Betrag übrig bleibt.
IShiftOperators<Byte,Int32,Byte>.RightShift(Byte, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
IShiftOperators<Byte,Int32,Byte>.UnsignedRightShift(Byte, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
ISubtractionOperators<Byte,Byte,Byte>.CheckedSubtraction(Byte, Byte)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
ISubtractionOperators<Byte,Byte,Byte>.Subtraction(Byte, Byte)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
IUnaryNegationOperators<Byte,Byte>.CheckedUnaryNegation(Byte)	Berechnet die überprüfte unäre Negation eines Werts.
IUnaryNegationOperators<Byte,Byte>.UnaryNegation(Byte)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<Byte,Byte>.UnaryPlus(Byte)	Berechnet das unäre Plus eines Werts.

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Elemente, die instance Zustand ändern, geben tatsächlich eine neue instance 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 instance dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

Weitere Informationen

• SByte
• IComparable
• IFormattable
• IConvertible
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (C#)
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (Visual Basic)