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 : IAdditionOperators<System::Byte, System::Byte, System::Byte>, IAdditiveIdentity<System::Byte, System::Byte>, IBinaryInteger<System::Byte>, IBinaryNumber<System::Byte>, IBitwiseOperators<System::Byte, System::Byte, System::Byte>, IComparable<System::Byte>, IComparisonOperators<System::Byte, System::Byte>, IConvertible, IDecrementOperators<System::Byte>, IDivisionOperators<System::Byte, System::Byte, System::Byte>, IEqualityOperators<System::Byte, System::Byte>, IEquatable<System::Byte>, IIncrementOperators<System::Byte>, IMinMaxValue<System::Byte>, IModulusOperators<System::Byte, System::Byte, System::Byte>, IMultiplicativeIdentity<System::Byte, System::Byte>, IMultiplyOperators<System::Byte, System::Byte, System::Byte>, INumber<System::Byte>, IParseable<System::Byte>, IShiftOperators<System::Byte, System::Byte>, ISpanParseable<System::Byte>, ISubtractionOperators<System::Byte, System::Byte, System::Byte>, IUnaryNegationOperators<System::Byte, System::Byte>, IUnaryPlusOperators<System::Byte, System::Byte>, IUnsignedNumber<System::Byte>
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 readonly struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public readonly struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, ISpanFormattable
public readonly struct Byte : IAdditionOperators<byte,byte,byte>, IAdditiveIdentity<byte,byte>, IBinaryInteger<byte>, IBinaryNumber<byte>, IBitwiseOperators<byte,byte,byte>, IComparable<byte>, IComparisonOperators<byte,byte>, IConvertible, IDecrementOperators<byte>, IDivisionOperators<byte,byte,byte>, IEqualityOperators<byte,byte>, IEquatable<byte>, IIncrementOperators<byte>, IMinMaxValue<byte>, IModulusOperators<byte,byte,byte>, IMultiplicativeIdentity<byte,byte>, IMultiplyOperators<byte,byte,byte>, INumber<byte>, IParseable<byte>, IShiftOperators<byte,byte>, ISpanParseable<byte>, ISubtractionOperators<byte,byte,byte>, IUnaryNegationOperators<byte,byte>, IUnaryPlusOperators<byte,byte>, IUnsignedNumber<byte>
[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
type byte = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface IBinaryInteger<byte>
    interface IBinaryNumber<byte>
    interface IBitwiseOperators<byte, byte, byte>
    interface INumber<byte>
    interface IAdditionOperators<byte, byte, byte>
    interface IAdditiveIdentity<byte, byte>
    interface IComparisonOperators<byte, byte>
    interface IEqualityOperators<byte, byte>
    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 IParseable<byte>
    interface ISpanParseable<byte>
    interface ISubtractionOperators<byte, byte, byte>
    interface IUnaryNegationOperators<byte, byte>
    interface IUnaryPlusOperators<byte, byte>
    interface IShiftOperators<byte, byte>
    interface IMinMaxValue<byte>
    interface IUnsignedNumber<byte>
[<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 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), IConvertible, IDecrementOperators(Of Byte), IDivisionOperators(Of Byte, Byte, Byte), IEqualityOperators(Of Byte, Byte), 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), IParseable(Of Byte), IShiftOperators(Of Byte, Byte), ISpanParseable(Of Byte), ISubtractionOperators(Of Byte, Byte, Byte), IUnaryNegationOperators(Of Byte, Byte), IUnaryPlusOperators(Of Byte, Byte), IUnsignedNumber(Of Byte)
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 nicht signierte Ganzzahlen mit Werten darstellt, die zwischen 0 (die durch die Byte.MinValue Konstante dargestellt werden) bis 255 (die durch die Byte.MaxValue Konstante dargestellt wird). .NET enthält auch einen signierten 8-Bit-Ganzzahlwerttyp, der Werte darstellt, SBytedie zwischen -128 und 127 liegen.

Instanziieren eines Bytewerts

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

  • Sie können eine Byte Variable deklarieren und ihm einen literalen ganzzahligen Wert zuweisen, der sich im Bereich des Byte Datentyps 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 nicht byte numerischen Wert zuweisen. Dies ist eine schmale Konvertierung, sodass ein Umwandlungsoperator in C# und F# oder eine Konvertierungsmethode in Visual Basic erforderlich ist, falls Option Strict vorhanden. Wenn der Nicht-Byte-Wert ein , oder Decimal ein SingleDoubleWert ist, der eine Bruchkomponente enthält, hängt die Behandlung des Bruchteils vom Compiler ab, der 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
    
    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. Im folgenden Beispiel wird die Konvertierung eines Arrays von Int32 Werten in Byte Werte veranschaulicht.

    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 Oder-Methode TryParse aufrufen, um die Zeichenfolgendarstellung eines Byte Werts in ein Byte. Die Zeichenfolge kann entweder 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
    
    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 standardmäßige mathematische Vorgänge wie Addition, Subtraktion, Division, Multiplikation, Subtraktion, Negation und unäre Negation. Wie bei den anderen integralen Typen unterstützt der Byte Typ auch die Bitweiser AND, OR, XORdie linke Schicht und die rechte Schichtoperatoren.

Sie können die standardmäßigen numerischen Operatoren verwenden, um zwei Byte Werte zu vergleichen, oder Sie können die CompareTo Methode Equals aufrufen.

Sie können auch die Member der Math Klasse aufrufen, um einen breiten Bereich numerischer Vorgänge auszuführen, einschließlich des Abrufens des absoluten Werts einer Zahl, berechnen des Quotienten und Rests aus der integralen Division, Bestimmen des Höchstwerts oder mindestwerts von zwei Ganzzahlen, Abrufen des Zeichens einer Zahl und Runden einer Zahl.

Darstellen eines Bytes als Zeichenfolge

Der Byte Typ bietet vollständige Unterstützung für Standard- und benutzerdefinierte numerische Formatzeichenfolgen. (Weitere Informationen finden Sie unter Formatierungstypen, Standard numerische Formatzeichenfolgen 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. Mithilfe des D-Formatbezeichners können Sie auch eine angegebene Anzahl von führenden Nullen in die Zeichenfolgendarstellung einschließen. Mithilfe des X-Formatbezeichners 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äre, oktale und hexadezimale Darstellung 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 dezimalen Bytewerten

Zusätzlich zum Arbeiten mit einzelnen Bytes als Dezimalwerte möchten Sie möglicherweise 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 jede der primitiven Datentypen in ein Bytearray konvertieren, und die BigInteger.ToByteArray Methode konvertiert einen Wert in ein BigInteger Bytearray.

Byte Werte werden nur in 8 Bit durch ihre Größe dargestellt, ohne ein Zeichenbit. Dies ist wichtig, wenn Sie bitweise Vorgänge für Byte Werte ausführen oder wenn Sie mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder Vergleichsvorgang für alle zwei nicht dezimalen Werte auszuführen, müssen beide Werte dieselbe Darstellung verwenden.

Wenn ein Vorgang auf zwei Byte Werten ausgeführt wird, teilen die Werte dieselbe Darstellung, sodass das Ergebnis korrekt ist. Dies wird im folgenden Beispiel veranschaulicht, das das kleinste Bit 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 mit nicht signierten und signierten Bits arbeiten, sind bitweise Vorgänge durch die Tatsache kompliziert, dass die SByte Werte die Zeichen- und Größendarstellung für positive Werte und die Ergänzungsdarstellung 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 Bits 2 und 4 eines Arrays von 8-Bit-signierten und nicht signierten 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

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. Elemente, die den Instanzstatus ändern möchten, 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 die Threadsicherheit zu gewährleisten.

Siehe auch