Byte Структура

Определение

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

System

Сборка:

System.Runtime.dll

Представляет 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 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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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 ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Byte> IParsable<TSelf> ISpanParsable<Byte> ISpanParsable<TSelf> IAdditionOperators<Byte,Byte,Byte> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Byte,Byte> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<Byte> IBinaryNumber<Byte> IBinaryNumber<TSelf> IBitwiseOperators<Byte,Byte,Byte> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Byte,Byte,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Byte> IDecrementOperators<TSelf> IDivisionOperators<Byte,Byte,Byte> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Byte,Byte,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<Byte> IIncrementOperators<TSelf> IMinMaxValue<Byte> IModulusOperators<Byte,Byte,Byte> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Byte,Byte> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Byte,Byte,Byte> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Byte> INumber<TSelf> INumberBase<Byte> INumberBase<TSelf> IShiftOperators<Byte,Int32,Byte> IShiftOperators<TSelf,Int32,TSelf> ISubtractionOperators<Byte,Byte,Byte> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Byte,Byte> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Byte,Byte> IUnaryPlusOperators<TSelf,TSelf> IUnsignedNumber<Byte> IUtf8SpanFormattable IUtf8SpanParsable<Byte> IUtf8SpanParsable<TSelf>

Комментарии

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

Создание экземпляра байтового значения

Экземпляр значения можно создать 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("{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
  

• Для преобразования любого поддерживаемого 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.
  

  open System
  
  let numbers = [| Int32.MinValue; -1; 0; 121; 340; Int32.MaxValue |]
  
  for number in numbers do
      try
          let result = Convert.ToByte number
          printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
  
      with :? OverflowException ->
          printfn $"The {number.GetType().Name} value {number} is outside the range of the Byte type."
  
  
  // The example displays the following output:
  //       The Int32 value -2147483648 is outside the range of the Byte type.
  //       The Int32 value -1 is outside the range of the Byte type.
  //       Converted the Int32 value 0 to the Byte value 0.
  //       Converted the Int32 value 121 to the Byte value 121.
  //       The Int32 value 340 is outside the range of the Byte type.
  //       The Int32 value 2147483647 is outside the range of the Byte type.
  

  Dim numbers() As Integer = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue }
  Dim result As Byte
  For Each number As Integer In numbers
     Try
        result = Convert.ToByte(number)
        Console.WriteLIne("Converted the {0} value {1} to the {2} value {3}.", _
                          number.GetType().Name, number, _
                          result.GetType().Name, result)
     Catch e As OverflowException
        Console.WriteLine("The {0} value {1} is outside the range of the Byte type.", _
                          number.GetType().Name, number)
     End Try
  Next
  ' The example displays the following output:
  '       The Int32 value -2147483648 is outside the range of the Byte type.
  '       The Int32 value -1 is outside the range of the Byte type.
  '       Converted the Int32 value 0 to the Byte value 0.
  '       Converted the Int32 value 121 to the Byte value 121.
  '       The Int32 value 340 is outside the range of the Byte type.
  '       The Int32 value 2147483647 is outside the range of the Byte type.
  

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

  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
  

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

Тип поддерживает стандартные 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, а BigInteger.ToByteArray метод преобразует значение в массив байтов.

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("{0} And {1} = {2}", byteValue, mask,
                           byteValue & mask);
      }
   }
}
// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244

open System
open System.Globalization

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

let mask = 0xFEuy
for value in values do
    let byteValue = Byte.Parse(value, NumberStyles.AllowHexSpecifier)
    printfn $"{byteValue} And {mask} = {byteValue &&& mask}"
                    

// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { Convert.ToString(12, 16), _
                                 Convert.ToString(123, 16), _
                                 Convert.ToString(245, 16) }
      
      Dim mask As Byte = &hFE
      For Each value As String In values
         Dim byteValue As Byte = Byte.Parse(value, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("{0} And {1} = {2}", byteValue, mask, _ 
                           byteValue And mask)
      Next         
   End Sub
End Module
' The example displays the following output:
'       12 And 254 = 12
'       123 And 254 = 122
'       245 And 254 = 244

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

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

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

public class Example
{
   public static void Main()
   {
      ByteString[] values = CreateArray(-15, 123, 245);

      byte mask = 0x14;        // Mask all bits but 2 and 4.

      foreach (ByteString strValue in values) {
         byte byteValue = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("{0} ({1}) And {2} ({3}) = {4} ({5})",
                           strValue.Sign * byteValue,
                           Convert.ToString(byteValue, 2),
                           mask, Convert.ToString(mask, 2),
                           (strValue.Sign & Math.Sign(mask)) * (byteValue & mask),
                           Convert.ToString(byteValue & mask, 2));
      }
   }

   private static ByteString[] CreateArray(params int[] values)
   {
      List<ByteString> byteStrings = new List<ByteString>();

      foreach (object value in values) {
         ByteString temp = new ByteString();
         int sign = Math.Sign((int) value);
         temp.Sign = sign;

         // Change two's complement to magnitude-only representation.
         temp.Value = Convert.ToString(((int) value) * sign, 16);

         byteStrings.Add(temp);
      }
      return byteStrings.ToArray();
   }
}
// The example displays the following output:
//       -15 (1111) And 20 (10100) = 4 (100)
//       123 (1111011) And 20 (10100) = 16 (10000)
//       245 (11110101) And 20 (10100) = 20 (10100)

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

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

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


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

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

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

// The example displays the following output:
//       -15 (1111) And 20 (10100) = 4 (100)
//       123 (1111011) And 20 (10100) = 16 (10000)
//       245 (11110101) And 20 (10100) = 20 (10100)

Imports System.Collections.Generic
Imports System.Globalization

Public Structure ByteString
   Public Value As String
   Public Sign As Integer
End Structure

Module Example
   Public Sub Main()
      Dim values() As ByteString = CreateArray(-15, 123, 245)
      
      Dim mask As Byte = &h14        ' Mask all bits but 2 and 4.
      
      For Each strValue As ByteString In values
         Dim byteValue As Byte = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("{0} ({1}) And {2} ({3}) = {4} ({5})", _ 
                           strValue.Sign * byteValue, _ 
                           Convert.ToString(byteValue, 2), _
                           mask, Convert.ToString(mask, 2), _
                           (strValue.Sign And Math.Sign(mask)) * (byteValue And mask), _
                           Convert.ToString(byteValue And mask, 2))
      Next         
   End Sub
   
   Private Function CreateArray(ParamArray values() As Object) As ByteString()
      Dim byteStrings As New List(Of ByteString)
      For Each value As Object In values
         Dim temp As New ByteString()
         Dim sign As Integer = Math.Sign(value)
         temp.Sign = sign
         ' Change two's complement to magnitude-only representation.
         value = value * sign

         temp.Value = Convert.ToString(value, 16)
         byteStrings.Add(temp)
      Next
      Return byteStrings.ToArray()
   End Function   
End Module
' The example displays the following output:
'       -15 (1111) And 20 (10100) = 4 (100)
'       123 (1111011) And 20 (10100) = 16 (10000)
'       245 (11110101) And 20 (10100) = 20 (10100)

Поля

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)	Определяет, является ли значение степенью 2.
LeadingZeroCount(Byte)	Вычисляет число начальных нулей в значении.
Log2(Byte)	Вычисляет значение log2.
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)	Преобразует строковое представление числа в его эквивалент типа Byte.
Parse(String, IFormatProvider)	Преобразует строковое представление числа в указанном формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа Byte.
Parse(String, NumberStyles)	Преобразует строковое представление числа с указанным стилем в его эквивалент в формате Byte.
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в указанном стиле и формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа Byte.
PopCount(Byte)	Вычисляет количество битов, заданных в значении .
RotateLeft(Byte, Int32)	Поворачивает значение влево на заданную величину.
RotateRight(Byte, Int32)	Поворачивает значение вправо на заданную величину.
Sign(Byte)	Вычисляет знак значения.
ToString()	Преобразует значение текущего объекта Byte в эквивалентное ему строковое представление.
ToString(IFormatProvider)	Преобразует числовое значение текущего объекта Byte в эквивалентное ему строковое представление с использованием указанных сведений об особенностях форматирования для данного языка и региональных параметров.
ToString(String)	Преобразует значение текущего объекта Byte в эквивалентное ему строковое представление с использованием заданного формата.
ToString(String, IFormatProvider)	Преобразует числовое значение текущего объекта 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>.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
• Пример: служебная программа форматирования .NET Core WinForms (C#)
• Пример: служебная программа форматирования .NET Core WinForms (Visual Basic)