Freigeben über


System.Byte-Struktur

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Byte ist ein unveränderlicher Werttyp, der unsignierte ganze Zahlen 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 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 numerischen Wert ohne Byte zuweisen. Dies ist eine schmale Konvertierung, daher ist ein Umwandlungsoperator in C# und F# oder eine Konvertierungsmethode in Visual Basic erforderlich, falls Option Strict aktiviert. Wenn der Nicht-Byte-Wert ein Single, Doubleoder Decimal ein Wert 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 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. 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.
    
    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 ParseTryParse Zeichenfolgendarstellung eines Werts in ein ByteByte. Die Zeichenfolge kann entweder dezimale oder hexadezimale Ziffern enthalten. Im folgenden Beispiel wird der Analysevorgang mithilfe einer dezimalen und einer hexadezimalen Zeichenfolge 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 bitweisen AND, OR, XORlinken Schicht- und Rechtsverschiebungsoperatoren.

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

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 des Re Standard der aus integraler Division, Bestimmen des Höchst- oder Minimalwerts von zwei ganzzahligen Zahlen, Abrufen des Vorzeichens einer Zahl und Runden einer Zahl.

Represent a Byte as a String

Der Byte Typ bietet vollständige Unterstützung für Standard- und benutzerdefinierte zahlenformatische Zeichenfolgen. (Weitere Informationen finden Sie unter Formatierungstypen, Standardmäßige numerische Formatzeichenfolgen und benutzerdefinierte Zahlenformatzeichenfolgen.) Am häufigsten werden Bytewerte jedoch ohne zusätzliche Formatierung oder als zweistellige Hexadezimalwerte als einstellige bis dreistellige Werte dargestellt.

Um einen Byte Wert als integrale Zeichenfolge ohne führende Nullen zu formatieren, können Sie die parameterlose ToString() Methode aufrufen. Mithilfe des Formatbezeichners "D" 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 Bytewerten ohne Dezimalzahl

Zusätzlich zum Arbeiten 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 primitiven Datentyp in ein Bytearray konvertieren, und die BigInteger.ToByteArray Methode konvertiert einen BigInteger Wert in ein Bytearray.

Byte Werte werden nur in 8 Bits 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. Zum Ausführen eines numerischen, booleschen oder Vergleichsvorgangs für zwei nicht dezimale Werte 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 korrekt ist. Dies wird im folgenden Beispiel veranschaulicht, das das Bit der niedrigsten Reihenfolge eines Byte Werts maskiert, um sicherzustellen, dass er sogar 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 Example1
    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 Zeichen- und Größendarstellung für positive Werte verwenden, und zwei Ergänzungsdarstellungen für negative Werte. Um einen sinnvollen 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 Example1
{
    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 Example2
    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)