Byte Структура

Определение

Пространство имен:

System

Сборки:

netstandard.dll, System.Runtime.dll

Исходный код:

Byte.cs

Представляет 8-разрядное целое число без знака.

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)

Наследование

Object

ValueType

Byte

Реализации

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>

Комментарии

Byte — это неизменяемый тип значения, представляющий незначенные целые числа со значениями, которые варьируются от 0 (который представлен константой Byte.MinValue) до 255 (которая представлена константой Byte.MaxValue). .NET также включает в себя 8-разрядный целочисленный тип, SByte, который представляет значения, которые варьируются от -128 до 127.

Создание экземпляра значения типа Byte

Можно создать экземпляр значения Byte несколькими способами:

• Можно объявить переменную Byte и назначить ей литеральное целочисленное значение, которое находится в диапазоне типа данных Byte. В следующем примере объявляется две переменные Byte и присваивают им значения таким образом.

  byte value1 = 64;
  byte value2 = 255;
  

  let value1 = 64uy
  let value2 = 255uy
  

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

• Числовое значение, не являющееся байтом, можно назначить байту. Это сужающее преобразование, поэтому требуется оператор приведения в C# и F# или метод преобразования в Visual Basic, если параметр Option Strict включен. Если значение, отличное от байтов, является Single, Doubleили Decimal значением, которое включает дробный компонент, обработка его дробной части зависит от компилятора, выполняющего преобразование. В следующем примере для Byte переменных назначается несколько числовых значений.

  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
  

• Можно вызвать метод класса Convert для преобразования любого поддерживаемого типа в значение Byte. Это возможно, так как Byte поддерживает интерфейс IConvertible. Следующий пример иллюстрирует преобразование массива значений Int32 в значения Byte.

  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.
  

• Чтобы преобразовать строковое представление значения Parse в TryParse, можно вызвать метод Byte или Byte. Строка может содержать десятичные или шестнадцатеричные цифры. В следующем примере показана операция синтаксического анализа с помощью десятичной и шестнадцатеричной строки.

  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
  

Выполнение операций со значениями байтов

Тип Byte поддерживает стандартные математические операции, такие как добавление, вычитание, деление, умножение, вычитание, отрицание и унарное отрицание. Как и другие целочисленные типы, тип Byte также поддерживает побитовые AND, OR, XOR, операторы сдвига влево и вправо.

Стандартные числовые операторы можно использовать для сравнения двух значений Byte или вызова метода CompareTo или Equals.

Вы также можете вызвать члены класса Math для выполнения широких числовых операций, включая получение абсолютного значения числа, вычисление кворента и остатка из целого деления, определение максимального или минимального значения двух целых чисел, получение знака числа и округление числа.

Представление байта в виде строки

Тип Byte обеспечивает полную поддержку стандартных и пользовательских строк числовых форматов. (Дополнительные сведения см. в типах форматирования, строках стандартного числового форматаи настраиваемых строк числовых форматов.) Однако чаще всего значения байтов представляются как однозначные и трехзначные значения без дополнительного форматирования или как шестнадцатеричные значения двухзначных значений.

Чтобы отформатировать значение Byte как целочисленную строку без начальных нулей, можно вызвать метод без параметров ToString(). Используя описатель формата "D", можно также включить указанное число начальных нулей в строковое представление. Используя описатель формата X, можно представить Byte значение в виде шестнадцатеричной строки. В следующем примере элементы в массиве значений Byte форматируется тремя способами.

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

Можно также отформатировать значение Byte как двоичное, восьмеричное, десятичное или шестнадцатеричное значение, вызвав метод ToString(Byte, Int32) и указав базу в качестве второго параметра метода. В следующем примере этот метод вызывается для отображения двоичных, восьмимерных и шестнадцатеричных представлений массива байтовых значений.

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

Работа с не десятичными значениями байтов

Помимо работы с отдельными байтами в качестве десятичных значений, может потребоваться выполнять побитовые операции со значениями байтов или работать с массивами байтов или с двоичными или шестнадцатеричными представлениями байтовых значений. Например, перегрузки метода BitConverter.GetBytes могут преобразовать каждый из примитивных типов данных в массив байтов, а метод BigInteger.ToByteArray преобразует значение BigInteger в массив байтов.

Byte значения представлены в 8 битах только по величине без знака. Это важно учитывать при выполнении побитовых операций с значениями Byte или при работе с отдельными битами. Для выполнения числовых, логических операций или сравнения для двух не десятичных значений оба значения должны использовать одно и то же представление.

При выполнении операции с двумя значениями Byte значения используют одно и то же представление, поэтому результат является точным. Это иллюстрируется в следующем примере, который маскирует бит наименьшего порядка значения Byte, чтобы убедиться, что оно четное.

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

С другой стороны, при работе с беззначными и подписанными битами побитовые операции усложняются тем, что значения SByte используют представление знака и величины для положительных значений, а также дополнительное представление двух для отрицательных значений. Чтобы выполнить значимую побитовую операцию, значения должны быть преобразованы в два эквивалентных представления, а сведения о бите знака должны быть сохранены. В следующем примере это применяется для маскирования битов 2 и 4 в массиве из 8-разрядных значений со знаком и беззнаковых значений.

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)

Поля

Имя	Описание
MaxValue	Представляет наибольшее возможное значение Byteобъекта. Это поле является константой.
MinValue	Представляет наименьшее возможное значение Byte. Это поле является константой.

Методы

Имя	Описание
Clamp(Byte, Byte, Byte)	Зацепляет значение к инклюзивному минимальному и максимальному значению.
CompareTo(Byte)	Сравнивает этот экземпляр с указанным 8-разрядным целым числом без знака и возвращает указание их относительных значений.
CompareTo(Object)	Сравнивает этот экземпляр с указанным объектом и возвращает указание их относительных значений.
CreateChecked<TOther>(TOther)	Создает экземпляр текущего типа из значения, вызывая исключение переполнения для всех значений, которые выходят за пределы представляющего диапазона текущего типа.
CreateSaturating<TOther>(TOther)	Создает экземпляр текущего типа из значения, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
CreateTruncating<TOther>(TOther)	Создает экземпляр текущего типа из значения, усечение всех значений, которые выходят за пределы представляющего диапазона текущего типа.
DivRem(Byte, Byte)	Вычисляет цитент и оставшуюся часть двух значений.
Equals(Byte)	Возвращает значение, указывающее, представляет ли этот экземпляр и указанный Byte объект одинаковые значения.
Equals(Object)	Возвращает значение, указывающее, равен ли этот экземпляр указанному объекту.
GetHashCode()	Возвращает хэш-код для этого экземпляра.
GetTypeCode()	TypeCode Возвращает тип Byteзначения.
IsEvenInteger(Byte)	Определяет, представляет ли значение даже целочисленное число.
IsOddInteger(Byte)	Определяет, представляет ли значение нечетное целочисленное число.
IsPow2(Byte)	Определяет, является ли значение двумя.
LeadingZeroCount(Byte)	Вычисляет число начальных нулей в значении.
Log2(Byte)	Вычисляет журнал 2 значения.
Max(Byte, Byte)	Сравнивает два значения с вычислениями, которые больше.
Min(Byte, Byte)	Сравнивает два значения с вычислениями, которые меньше.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Преобразует представление диапазона числа в указанном стиле и формате языка и региональных параметров в эквивалентный.Byte
Parse(String, IFormatProvider)	Преобразует строковое представление числа в указанном формате языка и региональных параметров в эквивалентный.Byte
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в указанном стиле и формате языка и региональных параметров в эквивалентный.Byte
Parse(String, NumberStyles)	Преобразует строковое представление числа в указанном стиле в его Byte эквивалент.
Parse(String)	Преобразует строковое представление числа в его Byte эквивалент.
PopCount(Byte)	Вычисляет количество битов, заданных в значении.
RotateLeft(Byte, Int32)	Поворот значения влево на заданное значение.
RotateRight(Byte, Int32)	Поворот значения вправо по заданному количеству.
Sign(Byte)	Вычисляет знак значения.
ToString()	Преобразует значение текущего Byte объекта в эквивалентное строковое представление.
ToString(IFormatProvider)	Преобразует числовое значение текущего Byte объекта в эквивалентное строковое представление, используя указанные сведения о форматировании, зависящие от языка и региональных параметров.
ToString(String, IFormatProvider)	Преобразует значение текущего Byte объекта в эквивалентное строковое представление, используя указанный формат и сведения о форматировании, относящиеся к языку и региональным параметрам.
ToString(String)	Преобразует значение текущего Byte объекта в эквивалентное строковое представление с помощью указанного формата.
TrailingZeroCount(Byte)	Вычисляет число конечных нулей в значении.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего экземпляра как UTF-8 в предоставленный диапазон байтов.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего 8-разрядного целого числа без знака в предоставленный диапазон символов.
TryParse(ReadOnlySpan<Byte>, Byte)	Пытается преобразовать диапазон символов UTF-8, содержащий строковое представление числа в его 8-разрядное целое число без знака.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Пытается проанализировать диапазон символов UTF-8 в значение.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Пытается проанализировать диапазон символов UTF-8 в значение.
TryParse(ReadOnlySpan<Char>, Byte)	Пытается преобразовать представление диапазона числа в его Byte эквивалент и возвращает значение, указывающее, успешно ли выполнено преобразование.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Пытается проанализировать диапазон символов в значение.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Преобразует представление диапазона числа в указанном стиле и формате языка и региональных параметров в эквивалентный.Byte Возвращаемое значение указывает, выполнено ли преобразование успешно или завершилось сбоем.
TryParse(String, Byte)	Пытается преобразовать строковое представление числа в его Byte эквивалент и возвращает значение, указывающее, выполнено ли преобразование успешно.
TryParse(String, IFormatProvider, Byte)	Пытается проанализировать строку в значение.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Преобразует строковое представление числа в указанном стиле и формате языка и региональных параметров в эквивалентный.Byte Возвращаемое значение указывает, выполнено ли преобразование успешно или завершилось сбоем.

Явные реализации интерфейса

Имя	Описание
IAdditionOperators<Byte,Byte,Byte>.Addition(Byte, Byte)	Добавляет два значения вместе для вычисления суммы.
IAdditionOperators<Byte,Byte,Byte>.CheckedAddition(Byte, Byte)	Добавляет два значения вместе для вычисления суммы.
IAdditiveIdentity<Byte,Byte>.AdditiveIdentity	Возвращает аддитивное удостоверение текущего типа.
IBinaryInteger<Byte>.GetByteCount()	Возвращает количество байтов, которые будут записываться в составе TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Byte>.GetShortestBitLength()	Возвращает длину (в битах) в кратчайшем представлении текущего значения.
IBinaryInteger<Byte>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Byte)	Представляет 8-разрядное целое число без знака.
IBinaryInteger<Byte>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Byte)	Представляет 8-разрядное целое число без знака.
IBinaryInteger<Byte>.TryWriteBigEndian(Span<Byte>, Int32)	Пытается записать текущее значение в формате big-endian в заданный диапазон.
IBinaryInteger<Byte>.TryWriteLittleEndian(Span<Byte>, Int32)	Пытается написать текущее значение в маленьком формате в заданном диапазоне.
IBinaryNumber<Byte>.AllBitsSet	Возвращает экземпляр двоичного типа, в котором заданы все биты.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseAnd(Byte, Byte)	Вычисляет битовое и два значения.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseOr(Byte, Byte)	Вычисляет битовое или два значения.
IBitwiseOperators<Byte,Byte,Byte>.ExclusiveOr(Byte, Byte)	Вычисляет монопольные или два значения.
IBitwiseOperators<Byte,Byte,Byte>.OnesComplement(Byte)	Вычисляет представление заданного значения с дополнением.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThan(Byte, Byte)	Сравнивает два значения, чтобы определить, какой из них больше.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThanOrEqual(Byte, Byte)	Сравнивает два значения, чтобы определить, какое значение больше или равно.
IComparisonOperators<Byte,Byte,Boolean>.LessThan(Byte, Byte)	Сравнивает два значения, чтобы определить, что меньше.
IComparisonOperators<Byte,Byte,Boolean>.LessThanOrEqual(Byte, Byte)	Сравнивает два значения, чтобы определить, что меньше или равно.
IConvertible.ToBoolean(IFormatProvider)	Описание этого элемента см. в разделе ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Описание этого элемента см. в разделе ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Описание этого элемента см. в разделе ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Это преобразование не поддерживается. Попытка использовать этот метод вызывает InvalidCastExceptionисключение.
IConvertible.ToDecimal(IFormatProvider)	Описание этого элемента см. в разделе ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Описание этого элемента см. в разделе ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Описание этого элемента см. в разделе ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Описание этого элемента см. в разделе ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Описание этого элемента см. в разделе ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Описание этого элемента см. в разделе ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Описание этого элемента см. в разделе ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Описание этого элемента см. в разделе ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Описание этого элемента см. в разделе ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Описание этого элемента см. в разделе ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Описание этого элемента см. в разделе ToUInt64(IFormatProvider).
IDecrementOperators<Byte>.CheckedDecrement(Byte)	Уменьшает значение.
IDecrementOperators<Byte>.Decrement(Byte)	Уменьшает значение.
IDivisionOperators<Byte,Byte,Byte>.Division(Byte, Byte)	Делит одно значение на другое, чтобы вычислить их кворот.
IEqualityOperators<Byte,Byte,Boolean>.Equality(Byte, Byte)	Сравнивает два значения для определения равенства.
IEqualityOperators<Byte,Byte,Boolean>.Inequality(Byte, Byte)	Сравнивает два значения для определения неравенства.
IIncrementOperators<Byte>.CheckedIncrement(Byte)	Увеличивает значение.
IIncrementOperators<Byte>.Increment(Byte)	Увеличивает значение.
IMinMaxValue<Byte>.MaxValue	Возвращает максимальное значение текущего типа.
IMinMaxValue<Byte>.MinValue	Возвращает минимальное значение текущего типа.
IModulusOperators<Byte,Byte,Byte>.Modulus(Byte, Byte)	Делит два значения вместе, чтобы вычислить их модулу или оставшуюся часть.
IMultiplicativeIdentity<Byte,Byte>.MultiplicativeIdentity	Возвращает умножающее удостоверение текущего типа.
IMultiplyOperators<Byte,Byte,Byte>.CheckedMultiply(Byte, Byte)	Умножает два значения вместе, чтобы вычислить свой продукт.
IMultiplyOperators<Byte,Byte,Byte>.Multiply(Byte, Byte)	Умножает два значения вместе, чтобы вычислить свой продукт.
INumber<Byte>.CopySign(Byte, Byte)	Копирует знак значения в знак другого значения.
INumber<Byte>.MaxNumber(Byte, Byte)	Сравнивает два значения с вычислениями, которые больше и возвращают другое значение, если входные данные.NaN
INumber<Byte>.MinNumber(Byte, Byte)	Сравнивает два значения с вычислениями, которые меньше и возвращают другое значение, если входные данные имеют NaNзначение.
INumberBase<Byte>.Abs(Byte)	Вычисляет абсолютное значение.
INumberBase<Byte>.IsCanonical(Byte)	Определяет, находится ли значение в его каноническом представлении.
INumberBase<Byte>.IsComplexNumber(Byte)	Определяет, представляет ли значение сложное число.
INumberBase<Byte>.IsFinite(Byte)	Определяет, является ли значение конечным.
INumberBase<Byte>.IsImaginaryNumber(Byte)	Определяет, представляет ли значение чистое мнимое число.
INumberBase<Byte>.IsInfinity(Byte)	Определяет, является ли значение бесконечным.
INumberBase<Byte>.IsInteger(Byte)	Определяет, представляет ли значение целочисленное число.
INumberBase<Byte>.IsNaN(Byte)	Определяет, является ли значение naN.
INumberBase<Byte>.IsNegative(Byte)	Определяет, является ли значение отрицательным.
INumberBase<Byte>.IsNegativeInfinity(Byte)	Определяет, является ли значение отрицательным бесконечностью.
INumberBase<Byte>.IsNormal(Byte)	Определяет, является ли значение нормальным.
INumberBase<Byte>.IsPositive(Byte)	Определяет, является ли значение положительным.
INumberBase<Byte>.IsPositiveInfinity(Byte)	Определяет, является ли значение положительным бесконечностью.
INumberBase<Byte>.IsRealNumber(Byte)	Определяет, представляет ли значение реальное число.
INumberBase<Byte>.IsSubnormal(Byte)	Определяет, является ли значение ненормальным.
INumberBase<Byte>.IsZero(Byte)	Определяет, равно ли значение нулю.
INumberBase<Byte>.MaxMagnitude(Byte, Byte)	Сравнивает два значения с вычислениями, которые больше.
INumberBase<Byte>.MaxMagnitudeNumber(Byte, Byte)	Сравнивает два значения с вычислениями, которые имеют большую величину и возвращают другое значение, если входные данные.NaN
INumberBase<Byte>.MinMagnitude(Byte, Byte)	Сравнивает два значения с вычислениями, которые меньше.
INumberBase<Byte>.MinMagnitudeNumber(Byte, Byte)	Сравнивает два значения с вычислениями, которые имеют меньшую величину и возвращают другое значение, если входные данные.NaN
INumberBase<Byte>.MultiplyAddEstimate(Byte, Byte, Byte)	Вычисляет оценку (left * right) + . addend
INumberBase<Byte>.One	Возвращает значение 1 типа.
INumberBase<Byte>.Radix	Возвращает радикс или базу для типа.
INumberBase<Byte>.TryConvertFromChecked<TOther>(TOther, Byte)	Представляет 8-разрядное целое число без знака.
INumberBase<Byte>.TryConvertFromSaturating<TOther>(TOther, Byte)	Представляет 8-разрядное целое число без знака.
INumberBase<Byte>.TryConvertFromTruncating<TOther>(TOther, Byte)	Представляет 8-разрядное целое число без знака.
INumberBase<Byte>.TryConvertToChecked<TOther>(Byte, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, вызывая исключение переполнения для любых значений, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Byte>.TryConvertToSaturating<TOther>(Byte, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Byte>.TryConvertToTruncating<TOther>(Byte, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, усечение любых значений, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Byte>.Zero	Возвращает значение 0 типа.
IShiftOperators<Byte,Int32,Byte>.LeftShift(Byte, Int32)	Сдвигает значение влево по заданной сумме.
IShiftOperators<Byte,Int32,Byte>.RightShift(Byte, Int32)	Сдвигает значение вправо по заданной сумме.
IShiftOperators<Byte,Int32,Byte>.UnsignedRightShift(Byte, Int32)	Сдвигает значение вправо по заданной сумме.
ISubtractionOperators<Byte,Byte,Byte>.CheckedSubtraction(Byte, Byte)	Вычитает два значения, чтобы вычислить их разницу.
ISubtractionOperators<Byte,Byte,Byte>.Subtraction(Byte, Byte)	Вычитает два значения, чтобы вычислить их разницу.
IUnaryNegationOperators<Byte,Byte>.CheckedUnaryNegation(Byte)	Вычисляет проверенное унарное отрицание значения.
IUnaryNegationOperators<Byte,Byte>.UnaryNegation(Byte)	Вычисляет унарное отрицание значения.
IUnaryPlusOperators<Byte,Byte>.UnaryPlus(Byte)	Вычисляет унарный плюс значения.

Потокобезопасность

Все члены этого типа являются потокобезопасны. Элементы, которые, как представляется, изменяют состояние экземпляра, фактически возвращают новый экземпляр, инициализированный с новым значением. Как и в случае с любым другим типом, чтение и запись в общую переменную, которая содержит экземпляр этого типа, должна быть защищена блокировкой, чтобы гарантировать безопасность потока.

См. также раздел

• SByte
• IComparable
• IFormattable
• IConvertible
• Пример: программа форматирования WinForms для .NET Core (C#)
• Пример: программа форматирования WinForms для .NET Core (Visual Basic)