Byte Struct-datatyp

Definition

Namnområde:

System

Sammansättningar:

netstandard.dll, System.Runtime.dll

Källa:

Byte.cs

Representerar ett 8-bitars osignerat heltal.

public value class System::Byte : IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, IParsable<System::Byte>, ISpanParsable<System::Byte>, IUtf8SpanParsable<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>, IUtf8SpanParsable<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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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), IUtf8SpanParsable(Of Byte)

Arv

Object

ValueType

Byte

Implementeringar

IComparable IComparable<Byte> IConvertible IEquatable<Byte> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Byte> IParsable<TSelf> ISpanFormattable ISpanParsable<Byte> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Byte> IUtf8SpanParsable<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>

Kommentarer

Byte är en oföränderlig värdetyp som representerar osignerade heltal med värden som sträcker sig från 0 (som representeras av Byte.MinValue konstant) till 255 (som representeras av Byte.MaxValue konstant). .NET innehåller också en signerad 8-bitars heltalsvärdetyp, SByte, som representerar värden som sträcker sig från -128 till 127.

Instansiera ett bytevärde

Du kan instansiera ett Byte värde på flera sätt:

• Du kan deklarera en Byte variabel och tilldela den ett literal heltalsvärde som ligger inom intervallet för den Byte datatypen. I följande exempel deklareras två Byte variabler och de tilldelas värden på det här sättet.

  byte value1 = 64;
  byte value2 = 255;
  

  let value1 = 64uy
  let value2 = 255uy
  

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

• Du kan tilldela ett numeriskt värde som inte är av typen byte, till en byte. Det här är en begränsad konvertering, så det kräver en cast-operator i C# och F#, eller en konverteringsmetod i Visual Basic om Option Strict är på. Om värdet som inte är byte är ett Single, Doubleeller Decimal värde som innehåller en delkomponent, beror hanteringen av deldelen på att kompilatorn utför konverteringen. I följande exempel tilldelas flera numeriska värden till Byte variabler.

  int int1 = 128;
  try
  {
      byte value1 = (byte)int1;
      Console.WriteLine(value1);
  }
  catch (OverflowException)
  {
      Console.WriteLine($"{int1} is out of range of a byte.");
  }
  
  double dbl2 = 3.997;
  try
  {
      byte value2 = (byte)dbl2;
      Console.WriteLine(value2);
  }
  catch (OverflowException)
  {
      Console.WriteLine($"{dbl2} is out of range of a byte.");
  }
  // 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
  

• Du kan anropa en metod i klassen Convert för att konvertera valfri typ som stöds till ett Byte värde. Detta är möjligt eftersom Byte stöder IConvertible-gränssnittet. I följande exempel visas konverteringen av en matris med Int32 värden till Byte värden.

  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.
  

• Du kan anropa metoden Parse eller TryParse för att konvertera strängrepresentationen av ett Byte-värde till en Byte. Strängen kan innehålla decimal- eller hexadecimala siffror. I följande exempel visas parsningsåtgärden med både en decimal och en hexadecimal sträng.

  string string1 = "244";
  try
  {
      byte byte1 = Byte.Parse(string1);
      Console.WriteLine(byte1);
  }
  catch (OverflowException)
  {
      Console.WriteLine($"'{string1}' is out of range of a byte.");
  }
  catch (FormatException)
  {
      Console.WriteLine($"'{string1}' is out of range of a byte.");
  }
  
  string string2 = "F9";
  try
  {
      byte byte2 = Byte.Parse(string2,
                              System.Globalization.NumberStyles.HexNumber);
      Console.WriteLine(byte2);
  }
  catch (OverflowException)
  {
      Console.WriteLine($"'{string2}' is out of range of a byte.");
  }
  catch (FormatException)
  {
      Console.WriteLine($"'{string2}' is out of range of a byte.");
  }
  // 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
  

Utföra åtgärder på bytevärden

Typen Byte stöder standardmatematiska operationer som addition, subtraktion, division, multiplikation, negation och unär negation. Precis som de andra integraltyperna stöder även den Byte-typen bitvis AND, OR, XOR, vänsterskift- och högerskiftoperatorer.

Du kan använda de numeriska standardoperatorerna för att jämföra två Byte värden, eller anropa metoden CompareTo eller Equals.

Du kan också anropa medlemmarna i klassen Math för att utföra ett brett spektrum av numeriska åtgärder, inklusive att hämta det absoluta värdet för ett tal, beräkna kvoten och resten från integraldivisionen, bestämma det maximala eller lägsta värdet för två heltal, hämta tecknet för ett tal och avrunda ett tal.

Representera en byte som en sträng

Byte-typen ger fullt stöd för standard- och anpassade numeriska formatsträngar. (Mer information finns i Formateringstyper, numeriska standardformatsträngaroch anpassade numeriska formatsträngar.) Vanligtvis representeras dock bytevärden som ensiffriga till tresiffriga värden utan ytterligare formatering eller som tvåsiffriga hexadecimala värden.

Om du vill formatera ett Byte värde som en integrerad sträng utan inledande nollor kan du anropa metoden parameterlös ToString(). Genom att använda formatspecificeraren "D" kan du även inkludera ett angivet antal inledande nollor i strängrepresentationen. Genom att använda formatspecificeraren "X" kan du representera ett Byte värde som en hexadecimal sträng. I följande exempel formateras elementen i en matris med Byte värden på dessa tre sätt.

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

Du kan också formatera ett Byte värde som en binär, oktal, decimal eller hexadecimal sträng genom att anropa metoden ToString(Byte, Int32) och ange basen som metodens andra parameter. I följande exempel anropas den här metoden för att visa binära, oktala och hexadecimala representationer av en matris med bytevärden.

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

Arbeta med icke-decimala bytevärden

Förutom att arbeta med enskilda byte som decimalvärden kanske du vill utföra bitvis åtgärder med bytevärden, eller arbeta med bytematriser eller med binära eller hexadecimala representationer av bytevärden. Till exempel kan överlagringar av metoden BitConverter.GetBytes konvertera var och en av de primitiva datatyperna till en bytematris, och metoden BigInteger.ToByteArray konverterar ett BigInteger-värde till en bytematris.

Byte-värden representeras endast i 8 bitar med deras magnitud, utan teckenbit. Detta är viktigt att tänka på när du utför bitvis åtgärder på Byte värden eller när du arbetar med enskilda bitar. Om du vill utföra en numerisk, boolesk eller jämförelseåtgärd på två icke-decimalvärden måste båda värdena använda samma representation.

När en åtgärd utförs på två Byte värden delar värdena samma representation, så resultatet är korrekt. Detta illustreras i följande exempel, som maskerar den lägsta delen av ett Byte värde för att säkerställa att det är jämnt.

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($"{byteValue} And {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

Å andra sidan, när du arbetar med både osignerade och signerade bitar, kompliceras bitvisa operationer av att SByte-värdena använder sign-magnitudrepresentation för positiva värden och tvåkomplementsrepresentation för negativa värden. För att kunna utföra en meningsfull bitvis åtgärd måste värdena konverteras till två motsvarande representationer och information om teckenbiten måste bevaras. Följande exempel gör detta för att maskera bitar 2 och 4 av en matris med 8-bitars signerade och osignerade värden.

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

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

public class BSExample1
{
    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($"{strValue.Sign * byteValue} ({Convert.ToString(byteValue, 2)}) And {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();

        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)

Fält

Name	Description
MaxValue	Representerar det största möjliga värdet för en Byte. Det här fältet är konstant.
MinValue	Representerar det minsta möjliga värdet för en Byte. Det här fältet är konstant.

Metoder

Name	Description
Clamp(Byte, Byte, Byte)	Klämmer fast ett värde till ett inkluderande lägsta och högsta värde.
CompareTo(Byte)	Jämför den här instansen med ett angivet 8-bitars osignerat heltal och returnerar en indikation på deras relativa värden.
CompareTo(Object)	Jämför den här instansen med ett angivet objekt och returnerar en indikation på deras relativa värden.
CreateChecked<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde, vilket utlöser ett spill-undantag för värden som ligger utanför det representerarbara intervallet för den aktuella typen.
CreateSaturating<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde som mättar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
CreateTruncating<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde och trunkerar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
DivRem(Byte, Byte)	Beräknar kvoten och resten av två värden.
Equals(Byte)	Returnerar ett värde som anger om den här instansen och ett angivet Byte objekt representerar samma värde.
Equals(Object)	Returnerar ett värde som anger om den här instansen är lika med ett angivet objekt.
GetHashCode()	Returnerar hash-koden för den här instansen.
GetTypeCode()	TypeCode Returnerar för värdetypen Byte.
IsEvenInteger(Byte)	Avgör om ett värde representerar ett jämnt heltal.
IsOddInteger(Byte)	Avgör om ett värde representerar ett udda integraltal.
IsPow2(Byte)	Avgör om ett värde är en kraft på två.
LeadingZeroCount(Byte)	Beräknar antalet inledande nollor i ett värde.
Log2(Byte)	Beräknar log2 för ett värde.
Max(Byte, Byte)	Jämför två värden med beräkning som är större.
Min(Byte, Byte)	Jämför två värden med beräkning som är mindre.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsar ett teckenintervall till ett värde.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konverterar spännviddsrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess Byte motsvarighet.
Parse(String, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess Byte motsvarighet.
Parse(String, NumberStyles, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess Byte motsvarighet.
Parse(String, NumberStyles)	Konverterar strängrepresentationen av ett tal i ett angivet format till dess Byte motsvarighet.
Parse(String)	Konverterar strängrepresentationen av ett tal till dess Byte motsvarighet.
PopCount(Byte)	Beräknar antalet bitar som anges i ett värde.
RotateLeft(Byte, Int32)	Roterar ett värde som lämnas av ett angivet belopp.
RotateRight(Byte, Int32)	Roterar ett värde höger med ett angivet belopp.
Sign(Byte)	Beräknar tecknet för ett värde.
ToString()	Konverterar värdet för det aktuella Byte objektet till motsvarande strängrepresentation.
ToString(IFormatProvider)	Konverterar det aktuella objektets numeriska värde Byte till motsvarande strängrepresentation med den angivna kulturspecifika formateringsinformationen.
ToString(String, IFormatProvider)	Konverterar värdet för det aktuella Byte objektet till motsvarande strängrepresentation med det angivna formatet och kulturspecifik formateringsinformation.
ToString(String)	Konverterar värdet för det aktuella Byte objektet till motsvarande strängrepresentation med det angivna formatet.
TrailingZeroCount(Byte)	Beräknar antalet avslutande nollor i ett värde.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella instansen som UTF-8 i det angivna byteintervallet.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella 8-bitars osignerade heltalsinstansen i det angivna intervallet med tecken.
TryParse(ReadOnlySpan<Byte>, Byte)	Försöker konvertera ett UTF-8-teckensintervall som innehåller strängrepresentationen av ett tal till dess 8-bitars osignerade heltalsmotsvarighet.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Försöker parsa ett intervall med UTF-8 tecken till ett värde.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Försöker parsa ett intervall med UTF-8 tecken till ett värde.
TryParse(ReadOnlySpan<Char>, Byte)	Försöker konvertera spanrepresentationen av ett tal till dess Byte motsvarighet och returnerar ett värde som anger om konverteringen lyckades.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Försöker parsa ett teckenintervall till ett värde.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Konverterar spännviddsrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess Byte motsvarighet. Ett returvärde anger om konverteringen lyckades eller misslyckades.
TryParse(String, Byte)	Försöker konvertera strängrepresentationen av ett tal till dess Byte motsvarighet och returnerar ett värde som anger om konverteringen lyckades.
TryParse(String, IFormatProvider, Byte)	Försöker parsa en sträng till ett värde.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess Byte motsvarighet. Ett returvärde anger om konverteringen lyckades eller misslyckades.

Explicita gränssnittsimplementeringar

Name	Description
IAdditionOperators<Byte,Byte,Byte>.Addition(Byte, Byte)	Lägger till två värden tillsammans för att beräkna summan.
IAdditionOperators<Byte,Byte,Byte>.CheckedAddition(Byte, Byte)	Lägger till två värden tillsammans för att beräkna summan.
IAdditiveIdentity<Byte,Byte>.AdditiveIdentity	Hämtar den aktuella typens additiva identitet.
IBinaryInteger<Byte>.GetByteCount()	Hämtar antalet byte som ska skrivas som en del av TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Byte>.GetShortestBitLength()	Hämtar längden, i bitar, på de kortaste tvås komplementrepresentation av det aktuella värdet.
IBinaryInteger<Byte>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Byte)	Representerar ett 8-bitars osignerat heltal.
IBinaryInteger<Byte>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Byte)	Representerar ett 8-bitars osignerat heltal.
IBinaryInteger<Byte>.TryWriteBigEndian(Span<Byte>, Int32)	Försöker skriva det aktuella värdet, i stor endianskt format, till ett givet intervall.
IBinaryInteger<Byte>.TryWriteLittleEndian(Span<Byte>, Int32)	Försöker skriva det aktuella värdet, i lite endianskt format, till ett givet intervall.
IBinaryNumber<Byte>.AllBitsSet	Hämtar en instans av den binära typen där alla bitar anges.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseAnd(Byte, Byte)	Beräknar bitvis och av två värden.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseOr(Byte, Byte)	Beräknar bitvis eller två värden.
IBitwiseOperators<Byte,Byte,Byte>.ExclusiveOr(Byte, Byte)	Beräknar uteslutande eller av två värden.
IBitwiseOperators<Byte,Byte,Byte>.OnesComplement(Byte)	Beräknar enkomplementrepresentationen av ett visst värde.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThan(Byte, Byte)	Jämför två värden för att avgöra vilket som är större.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThanOrEqual(Byte, Byte)	Jämför två värden för att avgöra vilket som är större eller lika med.
IComparisonOperators<Byte,Byte,Boolean>.LessThan(Byte, Byte)	Jämför två värden för att avgöra vilket som är mindre.
IComparisonOperators<Byte,Byte,Boolean>.LessThanOrEqual(Byte, Byte)	Jämför två värden för att avgöra vilket som är mindre eller lika med.
IConvertible.ToBoolean(IFormatProvider)	En beskrivning av den här medlemmen finns i ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	En beskrivning av den här medlemmen finns i ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	En beskrivning av den här medlemmen finns i ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Den här konverteringen stöds inte. Om du försöker använda den här metoden utlöser en InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	En beskrivning av den här medlemmen finns i ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	En beskrivning av den här medlemmen finns i ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	En beskrivning av den här medlemmen finns i ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	En beskrivning av den här medlemmen finns i ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	En beskrivning av den här medlemmen finns i ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt64(IFormatProvider).
IDecrementOperators<Byte>.CheckedDecrement(Byte)	Minskar ett värde.
IDecrementOperators<Byte>.Decrement(Byte)	Minskar ett värde.
IDivisionOperators<Byte,Byte,Byte>.Division(Byte, Byte)	Delar upp ett värde med ett annat för att beräkna deras kvot.
IEqualityOperators<Byte,Byte,Boolean>.Equality(Byte, Byte)	Jämför två värden för att fastställa likhet.
IEqualityOperators<Byte,Byte,Boolean>.Inequality(Byte, Byte)	Jämför två värden för att fastställa ojämlikhet.
IIncrementOperators<Byte>.CheckedIncrement(Byte)	Ökar ett värde.
IIncrementOperators<Byte>.Increment(Byte)	Ökar ett värde.
IMinMaxValue<Byte>.MaxValue	Hämtar det maximala värdet för den aktuella typen.
IMinMaxValue<Byte>.MinValue	Hämtar det lägsta värdet för den aktuella typen.
IModulusOperators<Byte,Byte,Byte>.Modulus(Byte, Byte)	Delar upp två värden för att beräkna deras modulus eller rest.
IMultiplicativeIdentity<Byte,Byte>.MultiplicativeIdentity	Hämtar den multiplicativa identiteten för den aktuella typen.
IMultiplyOperators<Byte,Byte,Byte>.CheckedMultiply(Byte, Byte)	Multiplicerar två värden tillsammans för att beräkna produkten.
IMultiplyOperators<Byte,Byte,Byte>.Multiply(Byte, Byte)	Multiplicerar två värden tillsammans för att beräkna produkten.
INumber<Byte>.CopySign(Byte, Byte)	Kopierar tecknet för ett värde till tecknet för ett annat värde.
INumber<Byte>.MaxNumber(Byte, Byte)	Jämför två värden med beräkning som är större och returnerar det andra värdet om en indata är NaN.
INumber<Byte>.MinNumber(Byte, Byte)	Jämför två värden med beräkning som är mindre och returnerar det andra värdet om en indata är NaN.
INumberBase<Byte>.Abs(Byte)	Beräknar det absoluta värdet.
INumberBase<Byte>.IsCanonical(Byte)	Avgör om ett värde finns i dess kanoniska representation.
INumberBase<Byte>.IsComplexNumber(Byte)	Avgör om ett värde representerar ett komplext tal.
INumberBase<Byte>.IsFinite(Byte)	Avgör om ett värde är begränsat.
INumberBase<Byte>.IsImaginaryNumber(Byte)	Avgör om ett värde representerar ett rent imaginärt tal.
INumberBase<Byte>.IsInfinity(Byte)	Avgör om ett värde är oändligt.
INumberBase<Byte>.IsInteger(Byte)	Avgör om ett värde representerar ett heltal.
INumberBase<Byte>.IsNaN(Byte)	Avgör om ett värde är NaN.
INumberBase<Byte>.IsNegative(Byte)	Avgör om ett värde är negativt.
INumberBase<Byte>.IsNegativeInfinity(Byte)	Avgör om ett värde är negativ oändlighet.
INumberBase<Byte>.IsNormal(Byte)	Avgör om ett värde är normalt.
INumberBase<Byte>.IsPositive(Byte)	Avgör om ett värde är positivt.
INumberBase<Byte>.IsPositiveInfinity(Byte)	Avgör om ett värde är positiv oändlighet.
INumberBase<Byte>.IsRealNumber(Byte)	Avgör om ett värde representerar ett verkligt tal.
INumberBase<Byte>.IsSubnormal(Byte)	Avgör om ett värde är subnormalt.
INumberBase<Byte>.IsZero(Byte)	Avgör om ett värde är noll.
INumberBase<Byte>.MaxMagnitude(Byte, Byte)	Jämför två värden med beräkning som är större.
INumberBase<Byte>.MaxMagnitudeNumber(Byte, Byte)	Jämför två värden med beräkning som har större storlek och returnerar det andra värdet om en indata är NaN.
INumberBase<Byte>.MinMagnitude(Byte, Byte)	Jämför två värden med beräkning som är mindre.
INumberBase<Byte>.MinMagnitudeNumber(Byte, Byte)	Jämför två värden med beräkning som har mindre storlek och returnerar det andra värdet om en indata är NaN.
INumberBase<Byte>.MultiplyAddEstimate(Byte, Byte, Byte)	Beräknar en uppskattning av (left * right) + addend.
INumberBase<Byte>.One	Hämtar värdet 1 för typen.
INumberBase<Byte>.Radix	Hämtar radixet, eller basen, för typen.
INumberBase<Byte>.TryConvertFromChecked<TOther>(TOther, Byte)	Representerar ett 8-bitars osignerat heltal.
INumberBase<Byte>.TryConvertFromSaturating<TOther>(TOther, Byte)	Representerar ett 8-bitars osignerat heltal.
INumberBase<Byte>.TryConvertFromTruncating<TOther>(TOther, Byte)	Representerar ett 8-bitars osignerat heltal.
INumberBase<Byte>.TryConvertToChecked<TOther>(Byte, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket utlöser ett spill-undantag för värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Byte>.TryConvertToSaturating<TOther>(Byte, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket mättar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Byte>.TryConvertToTruncating<TOther>(Byte, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ och trunkerar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Byte>.Zero	Hämtar värdet 0 för typen.
IShiftOperators<Byte,Int32,Byte>.LeftShift(Byte, Int32)	Flyttar ett värde som lämnas av ett visst belopp.
IShiftOperators<Byte,Int32,Byte>.RightShift(Byte, Int32)	Flyttar ett värde efter ett visst belopp.
IShiftOperators<Byte,Int32,Byte>.UnsignedRightShift(Byte, Int32)	Flyttar ett värde efter ett visst belopp.
ISubtractionOperators<Byte,Byte,Byte>.CheckedSubtraction(Byte, Byte)	Subtraherar två värden för att beräkna skillnaden.
ISubtractionOperators<Byte,Byte,Byte>.Subtraction(Byte, Byte)	Subtraherar två värden för att beräkna skillnaden.
IUnaryNegationOperators<Byte,Byte>.CheckedUnaryNegation(Byte)	Beräknar den kontrollerade obevakade negationen av ett värde.
IUnaryNegationOperators<Byte,Byte>.UnaryNegation(Byte)	Beräknar en oharisk negation av ett värde.
IUnaryPlusOperators<Byte,Byte>.UnaryPlus(Byte)	Beräknar det unary plus av ett värde.

Trådsäkerhet

Alla medlemmar av den här typen är trådsäkra. Medlemmar som verkar ändra instanstillstånd returnerar faktiskt en ny instans som initierats med det nya värdet. Precis som med andra typer måste läsning och skrivning till en delad variabel som innehåller en instans av den här typen skyddas av ett lås för att garantera trådsäkerheten.

Se även

• SByte
• IComparable
• IFormattable
• IConvertible
• Exempel: Formateringsverktyget för .NET Core WinForms (C#)
• Exempel: Formateringsverktyget för .NET Core WinForms (Visual Basic)