Byte Yapı

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

Byte.cs

8 bit işaretsiz tamsayıyı temsil eder.

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)

Devralma

Object

ValueType

Byte

Uygulamalar

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>

Açıklamalar

Byte , 0 değerini (sabit Byte.MinValue ile temsil edilir) ve 255 değerini (sabit Byte.MaxValue ile temsil edilir) içeren işaretsiz tamsayıları temsil eden değişmeyen bir değer türüdür. .NET ayrıca, SByte-128 ile 127 arasında değişen değerleri temsil eden imzalı bir 8 bit tamsayı değer türü de içerir.

Bayt değeri oluşturma

Bir değerin örneğini Byte çeşitli yollarla oluşturabilirsiniz:

• Bir Byte değişken bildirebilir ve veri türü aralığı Byte içinde bir değişmez tamsayı değeri atayabilirsiniz. Aşağıdaki örnek, iki Byte değişkeni bildirir ve bunlara bu şekilde değerler atar.

  byte value1 = 64;
  byte value2 = 255;
  

  let value1 = 64uy
  let value2 = 255uy
  

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

• Bayt olmayan bir sayısal değeri bayt olarak atayabilirsiniz. Bu bir daraltma dönüştürmesi olduğundan, C# ve F# dilinde bir dönüştürme işleci veya Option Strict açıksa Visual Basic'te bir dönüştürme yöntemi gerektirir. Bayt olmayan değer kesirli bileşen içeren bir Single, Doubleveya Decimal değeriyse, kesirli bölümünün işlenmesi, dönüştürmeyi gerçekleştiren derleyiciye bağlıdır. Aşağıdaki örnek değişkenlere Byte birkaç sayısal değer atar.

  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
  

• Desteklenen herhangi bir türü bir Convert değerine dönüştürmek için Byte sınıfının bir yöntemini çağırabilirsiniz. Byte IConvertible arabirimini desteklediğinden bu mümkündür. Aşağıdaki örnekte, Int32 değer dizisinin Byte değerlere dönüştürülmesi gösterilmektedir.

  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.
  

• Bir değerin Parse dize gösterimini TryParse değerine dönüştürmek için Byteveya Byte yöntemini çağırabilirsiniz. Dize ondalık veya onaltılık sayıları içerebilir. Aşağıdaki örnek, hem ondalık hem de onaltılık dize kullanarak ayrıştırma işlemini gösterir.

  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
  

Bayt değerlerinde işlem gerçekleştirme

türü Byte toplama, çıkarma, bölme, çarpma, çıkarma, olumsuzlama ve tekli olumsuzlama gibi standart matematiksel işlemleri destekler. Diğer integral türleri gibi, Byte türü de bit tabanlı AND, OR, XOR, sol shift ve sağ shift işleçlerini destekler.

İki Byte değeri karşılaştırmak için standart sayısal işleçleri kullanabilir veya CompareTo veya Equals yöntemini çağırabilirsiniz.

Ayrıca Math sınıfının üyelerini çağırarak bir sayının mutlak değerini alma, tamsayıdan bölüm ve kalan değerleri hesaplama, iki tamsayının maksimum veya en düşük değerini belirleme, sayının işaretini alma ve sayıyı yuvarlama gibi çok çeşitli sayısal işlemler gerçekleştirebilirsiniz.

Bayt dize olarak temsil

Byte türü, standart ve özel sayısal biçim dizeleri için tam destek sağlar. (Daha fazla bilgi için bkz . Biçimlendirme Türleri, Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.) Ancak en yaygın olarak bayt değerleri, ek biçimlendirme olmadan tek basamaklı ile üç basamaklı değerler veya iki basamaklı onaltılık değerler olarak temsil edilir.

Bir Byte değeri başta sıfır olmadan bir tamser dize olarak biçimlendirmek için parametresiz ToString() yöntemini çağırabilirsiniz. "D" biçim tanımlayıcısını kullanarak, dize gösterimine belirtilen sayıda baştaki sıfır da ekleyebilirsiniz. "X" biçim tanımlayıcısını kullanarak, bir Byte değeri onaltılık dize olarak temsil edebilirsiniz. Aşağıdaki örnek, bir değer dizisindeki Byte öğeleri bu üç yolla biçimlendirir.

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

Bir Byte değerini ikili, sekizlik, ondalık veya onaltılık dize olarak biçimlendirmek için ToString(Byte, Int32) yöntemini çağırabilir ve tabanı yöntemin ikinci parametresi olarak sağlayabilirsiniz. Aşağıdaki örnek, bayt değerleri dizisinin ikili, sekizli ve onaltılık gösterimlerini görüntülemek için bu yöntemi çağırır.

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

Ondalık olmayan Bayt değerleriyle çalışma

Ondalık değer olarak tek tek baytlarla çalışmanın yanı sıra bayt değerleriyle bit düzeyinde işlemler gerçekleştirmek veya bayt dizileriyle ya da bayt değerlerinin ikili veya onaltılı gösterimleriyle çalışmak isteyebilirsiniz. Örneğin, yönteminin BitConverter.GetBytes aşırı yüklemeleri ilkel veri türlerinin her birini bayt dizisine dönüştürebilir ve BigInteger.ToByteArray yöntemi bir BigInteger değeri bayt dizisine dönüştürür.

Byte değerler, işaret biti olmadan yalnızca büyüklüklerine göre 8 bit olarak temsil edilir. Bu, Byte değerlerde bit düzeyinde işlemler gerçekleştirirken veya tek tek bitlerle çalışırken göz önünde bulundurmanız önemlidir. Ondalık olmayan iki değer üzerinde sayısal, Boole veya karşılaştırma işlemi gerçekleştirmek için her iki değerin de aynı gösterimi kullanması gerekir.

bir işlem iki Byte değer üzerinde gerçekleştirildiğinde, değerler aynı gösterimi paylaşır, bu nedenle sonuç doğru olur. Bu, bir Byte değerinin en düşük sıralı bitini maskeleyen ve eşit olduğundan emin olan aşağıdaki örnekte gösterilmiştir.

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

Öte yandan, hem işaretsiz hem de imzalı bitlerle çalışırken, bit düzeyinde işlemler değerlerin SByte pozitif değerler için işaret ve büyüklük gösterimi ve negatif değerler için ikinin tamamlayıcı gösterimini kullanmasıyla karmaşıktır. Anlamlı bir bit düzeyinde işlem gerçekleştirmek için değerlerin iki eşdeğer gösterime dönüştürülmesi ve işaret biti hakkındaki bilgilerin korunması gerekir. Aşağıdaki örnek, 8 bit imzalı ve imzasız değerler dizisinin 2. ve 4. bitlerini maskelemesi için bunu yapar.

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)

Alanlar

Name	Description
MaxValue	Bir öğesinin mümkün olan en büyük değerini Bytetemsil eder. Bu alan sabittir.
MinValue	Bir öğesinin mümkün olan en küçük değerini Bytetemsil eder. Bu alan sabittir.

Yöntemler

Name	Description
Clamp(Byte, Byte, Byte)	Bir değeri kapsayıcı en düşük ve en yüksek değere kelepçeler.
CompareTo(Byte)	Bu örneği belirtilen 8 bit işaretsiz tamsayıyla karşılaştırır ve göreli değerlerinin bir göstergesini döndürür.
CompareTo(Object)	Bu örneği belirtilen bir nesneyle karşılaştırır ve göreli değerlerinin bir göstergesini döndürür.
CreateChecked<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için taşma özel durumu oluşturur.
CreateSaturating<TOther>(TOther)	Bir değerden geçerli türün bir örneğini oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri doygun hale getirir.
CreateTruncating<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri kesebilir.
DivRem(Byte, Byte)	İki değerin bölümünü ve kalan bölümünü hesaplar.
Equals(Byte)	Bu örneğin ve belirtilen Byte nesnenin aynı değeri temsil edip etmediğini belirten bir değer döndürür.
Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
GetHashCode()	Bu örneğin karma kodunu döndürür.
GetTypeCode()	değer türü TypeCodeiçin değerini Byte döndürür.
IsEvenInteger(Byte)	Bir değerin çift tamsayı sayıyı temsil eder olup olmadığını belirler.
IsOddInteger(Byte)	Bir değerin tek bir tamsayı sayısını temsil ediyor olup olmadığını belirler.
IsPow2(Byte)	Bir değerin ikinin gücü olup olmadığını belirler.
LeadingZeroCount(Byte)	Bir değerdeki baştaki sıfırların sayısını hesaplar.
Log2(Byte)	Bir değerin 2. günlüğünü hesaplar.
Max(Byte, Byte)	daha büyük olan iki değeri işlemle karşılaştırır.
Min(Byte, Byte)	daha az olan iki değeri işlemle karşılaştırır.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının span gösterimini eşdeğerine Byte dönüştürür.
Parse(String, IFormatProvider)	Belirli bir kültüre özgü biçimdeki bir sayının dize gösterimini eşdeğerine Byte dönüştürür.
Parse(String, NumberStyles, IFormatProvider)	Belirtilen stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini eşdeğerine Byte dönüştürür.
Parse(String, NumberStyles)	Belirtilen stildeki bir sayının dize gösterimini eşdeğerine Byte dönüştürür.
Parse(String)	Bir sayının dize gösterimini eşdeğerine Byte dönüştürür.
PopCount(Byte)	Bir değerde ayarlanan bit sayısını hesaplar.
RotateLeft(Byte, Int32)	Değeri belirli bir miktar sola döndürür.
RotateRight(Byte, Int32)	Değeri belirli bir miktara göre sağa döndürür.
Sign(Byte)	Bir değerin işaretini hesaplar.
ToString()	Geçerli Byte nesnenin değerini eşdeğer dize gösterimine dönüştürür.
ToString(IFormatProvider)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak geçerli Byte nesnenin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String, IFormatProvider)	Belirtilen biçim ve kültüre özgü biçimlendirme bilgilerini kullanarak geçerli Byte nesnenin değerini eşdeğer dize gösterimine dönüştürür.
ToString(String)	Belirtilen biçimi kullanarak geçerli Byte nesnenin değerini eşdeğer dize gösterimine dönüştürür.
TrailingZeroCount(Byte)	Bir değerdeki sondaki sıfırların sayısını hesaplar.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini UTF-8 olarak sağlanan bayt aralığına biçimlendirmeye çalışır.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli 8 bit işaretsiz tamsayı örneğinin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.
TryParse(ReadOnlySpan<Byte>, Byte)	Bir sayının dize gösterimini içeren UTF-8 karakter aralığını 8 bit işaretsiz tamsayı eşdeğerine dönüştürmeye çalışır.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, Byte)	Bir sayının span gösterimini eşdeğerine Byte dönüştürmeye çalışır ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Bir karakter aralığını bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının span gösterimini eşdeğerine Byte dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.
TryParse(String, Byte)	Bir sayının dize gösterimini eşdeğerine Byte dönüştürmeye çalışır ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.
TryParse(String, IFormatProvider, Byte)	Bir dizeyi bir değere ayrıştırmaya çalışır.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Belirtilen stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini eşdeğerine Byte dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.

Belirtik Arabirim Kullanımları

Name	Description
IAdditionOperators<Byte,Byte,Byte>.Addition(Byte, Byte)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditionOperators<Byte,Byte,Byte>.CheckedAddition(Byte, Byte)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditiveIdentity<Byte,Byte>.AdditiveIdentity	Geçerli türün ek kimliğini alır.
IBinaryInteger<Byte>.GetByteCount()	bir parçası TryWriteLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.
IBinaryInteger<Byte>.GetShortestBitLength()	Geçerli değerin en kısa ikisinin tamamlayıcı gösteriminin bit cinsinden uzunluğunu alır.
IBinaryInteger<Byte>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Byte)	8 bit işaretsiz tamsayıyı temsil eder.
IBinaryInteger<Byte>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Byte)	8 bit işaretsiz tamsayıyı temsil eder.
IBinaryInteger<Byte>.TryWriteBigEndian(Span<Byte>, Int32)	Geçerli değeri büyük endian biçiminde belirli bir span'a yazmaya çalışır.
IBinaryInteger<Byte>.TryWriteLittleEndian(Span<Byte>, Int32)	Geçerli değeri küçük endian biçiminde belirli bir span'a yazmaya çalışır.
IBinaryNumber<Byte>.AllBitsSet	Tüm bitlerin ayarlandığı ikili türün bir örneğini alır.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseAnd(Byte, Byte)	İki değerin bit düzeyinde ve değerini hesaplar.
IBitwiseOperators<Byte,Byte,Byte>.BitwiseOr(Byte, Byte)	bit düzeyinde veya iki değeri hesaplar.
IBitwiseOperators<Byte,Byte,Byte>.ExclusiveOr(Byte, Byte)	İki değerin özel veya özel değerini hesaplar.
IBitwiseOperators<Byte,Byte,Byte>.OnesComplement(Byte)	Belirli bir değerin bire tamamlayan gösterimini hesaplar.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThan(Byte, Byte)	Hangisinin daha büyük olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<Byte,Byte,Boolean>.GreaterThanOrEqual(Byte, Byte)	Hangisinin daha büyük veya eşit olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<Byte,Byte,Boolean>.LessThan(Byte, Byte)	Hangisinin daha az olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<Byte,Byte,Boolean>.LessThanOrEqual(Byte, Byte)	Hangisinin daha az veya eşit olduğunu belirlemek için iki değeri karşılaştırır.
IConvertible.ToBoolean(IFormatProvider)	Bu üyenin açıklaması için bkz ToBoolean(IFormatProvider). .
IConvertible.ToByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToByte(IFormatProvider). .
IConvertible.ToChar(IFormatProvider)	Bu üyenin açıklaması için bkz ToChar(IFormatProvider). .
IConvertible.ToDateTime(IFormatProvider)	Bu dönüştürme desteklenmez. Bu yöntemi kullanmaya çalışmak bir InvalidCastExceptionoluşturur.
IConvertible.ToDecimal(IFormatProvider)	Bu üyenin açıklaması için bkz ToDecimal(IFormatProvider). .
IConvertible.ToDouble(IFormatProvider)	Bu üyenin açıklaması için bkz ToDouble(IFormatProvider). .
IConvertible.ToInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt16(IFormatProvider). .
IConvertible.ToInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt32(IFormatProvider). .
IConvertible.ToInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt64(IFormatProvider). .
IConvertible.ToSByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToSByte(IFormatProvider). .
IConvertible.ToSingle(IFormatProvider)	Bu üyenin açıklaması için bkz ToSingle(IFormatProvider). .
IConvertible.ToType(Type, IFormatProvider)	Bu üyenin açıklaması için bkz ToType(Type, IFormatProvider). .
IConvertible.ToUInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt16(IFormatProvider). .
IConvertible.ToUInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt32(IFormatProvider). .
IConvertible.ToUInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt64(IFormatProvider). .
IDecrementOperators<Byte>.CheckedDecrement(Byte)	Bir değeri azaltma.
IDecrementOperators<Byte>.Decrement(Byte)	Bir değeri azaltma.
IDivisionOperators<Byte,Byte,Byte>.Division(Byte, Byte)	Kendi bölümünü hesaplamak için bir değeri diğerine böler.
IEqualityOperators<Byte,Byte,Boolean>.Equality(Byte, Byte)	Eşitliği belirlemek için iki değeri karşılaştırır.
IEqualityOperators<Byte,Byte,Boolean>.Inequality(Byte, Byte)	Eşitsizliği belirlemek için iki değeri karşılaştırır.
IIncrementOperators<Byte>.CheckedIncrement(Byte)	Bir değeri artırır.
IIncrementOperators<Byte>.Increment(Byte)	Bir değeri artırır.
IMinMaxValue<Byte>.MaxValue	Geçerli türün en büyük değerini alır.
IMinMaxValue<Byte>.MinValue	Geçerli türün en düşük değerini alır.
IModulusOperators<Byte,Byte,Byte>.Modulus(Byte, Byte)	Modüllerini veya kalan değerlerini hesaplamak için iki değeri birbirine böler.
IMultiplicativeIdentity<Byte,Byte>.MultiplicativeIdentity	Geçerli türün çarpımlı kimliğini alır.
IMultiplyOperators<Byte,Byte,Byte>.CheckedMultiply(Byte, Byte)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
IMultiplyOperators<Byte,Byte,Byte>.Multiply(Byte, Byte)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
INumber<Byte>.CopySign(Byte, Byte)	Bir değerin işaretini başka bir değerin işaretine kopyalar.
INumber<Byte>.MaxNumber(Byte, Byte)	daha büyük olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
INumber<Byte>.MinNumber(Byte, Byte)	daha küçük olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
INumberBase<Byte>.Abs(Byte)	Bir değerin mutlak değerini hesaplar.
INumberBase<Byte>.IsCanonical(Byte)	Bir değerin kurallı gösteriminde olup olmadığını belirler.
INumberBase<Byte>.IsComplexNumber(Byte)	Bir değerin karmaşık bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Byte>.IsFinite(Byte)	Bir değerin sonlu olup olmadığını belirler.
INumberBase<Byte>.IsImaginaryNumber(Byte)	Bir değerin saf bir sanal sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Byte>.IsInfinity(Byte)	Bir değerin sonsuz olup olmadığını belirler.
INumberBase<Byte>.IsInteger(Byte)	Bir değerin tam sayı olup olmadığını belirler.
INumberBase<Byte>.IsNaN(Byte)	Bir değerin NaN olup olmadığını belirler.
INumberBase<Byte>.IsNegative(Byte)	Bir değerin negatif olup olmadığını belirler.
INumberBase<Byte>.IsNegativeInfinity(Byte)	Bir değerin negatif sonsuz olup olmadığını belirler.
INumberBase<Byte>.IsNormal(Byte)	Bir değerin normal olup olmadığını belirler.
INumberBase<Byte>.IsPositive(Byte)	Bir değerin pozitif olup olmadığını belirler.
INumberBase<Byte>.IsPositiveInfinity(Byte)	Bir değerin pozitif sonsuz olup olmadığını belirler.
INumberBase<Byte>.IsRealNumber(Byte)	Bir değerin gerçek bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Byte>.IsSubnormal(Byte)	Bir değerin normalin altında olup olmadığını belirler.
INumberBase<Byte>.IsZero(Byte)	Değerin sıfır olup olmadığını belirler.
INumberBase<Byte>.MaxMagnitude(Byte, Byte)	daha büyük olan iki değeri işlemle karşılaştırır.
INumberBase<Byte>.MaxMagnitudeNumber(Byte, Byte)	İki değeri, daha büyük bir büyüklüğe sahip olan ve giriş ise diğer değeri döndüren işlemle karşılaştırır NaN.
INumberBase<Byte>.MinMagnitude(Byte, Byte)	daha az olan iki değeri işlemle karşılaştırır.
INumberBase<Byte>.MinMagnitudeNumber(Byte, Byte)	daha az büyüklüğe sahip olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
INumberBase<Byte>.MultiplyAddEstimate(Byte, Byte, Byte)	(left * right) + addendtahminini hesaplar.
INumberBase<Byte>.One	Türün değerini 1 alır.
INumberBase<Byte>.Radix	Türün radiksini veya tabanını alır.
INumberBase<Byte>.TryConvertFromChecked<TOther>(TOther, Byte)	8 bit işaretsiz tamsayıyı temsil eder.
INumberBase<Byte>.TryConvertFromSaturating<TOther>(TOther, Byte)	8 bit işaretsiz tamsayıyı temsil eder.
INumberBase<Byte>.TryConvertFromTruncating<TOther>(TOther, Byte)	8 bit işaretsiz tamsayıyı temsil eder.
INumberBase<Byte>.TryConvertToChecked<TOther>(Byte, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için bir taşma özel durumu oluşturur.
INumberBase<Byte>.TryConvertToSaturating<TOther>(Byte, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri doygunluğa getirir.
INumberBase<Byte>.TryConvertToTruncating<TOther>(Byte, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeye çalışır ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri kısaltır.
INumberBase<Byte>.Zero	Türün değerini 0 alır.
IShiftOperators<Byte,Int32,Byte>.LeftShift(Byte, Int32)	Değeri belirli bir miktar sola kaydırıyor.
IShiftOperators<Byte,Int32,Byte>.RightShift(Byte, Int32)	Değeri belirli bir miktar sağa kaydırıyor.
IShiftOperators<Byte,Int32,Byte>.UnsignedRightShift(Byte, Int32)	Değeri belirli bir miktar sağa kaydırıyor.
ISubtractionOperators<Byte,Byte,Byte>.CheckedSubtraction(Byte, Byte)	Farklarını hesaplamak için iki değeri çıkarır.
ISubtractionOperators<Byte,Byte,Byte>.Subtraction(Byte, Byte)	Farklarını hesaplamak için iki değeri çıkarır.
IUnaryNegationOperators<Byte,Byte>.CheckedUnaryNegation(Byte)	Bir değerin denetlenen bir tekli olumsuzlamasını hesaplar.
IUnaryNegationOperators<Byte,Byte>.UnaryNegation(Byte)	Bir değerin tekli olumsuzlamasını hesaplar.
IUnaryPlusOperators<Byte,Byte>.UnaryPlus(Byte)	Bir değerin birli artısını hesaplar.

İş Parçacığı Güvenliği

Bu türün tüm üyeleri iş parçacığı güvenlidir. Örnek durumunu değiştirmek için görünen üyeler aslında yeni değerle başlatılan yeni bir örnek döndürür. Diğer türlerde olduğu gibi, iş parçacığı güvenliğini garanti etmek için bu türün bir örneğini içeren paylaşılan bir değişkene okuma ve yazma bir kilit tarafından korunmalıdır.

Ayrıca bkz.

• SByte
• IComparable
• IFormattable
• IConvertible
• Örneği: .NET Core WinForms Biçimlendirme Yardımcı Programı (C#)
• Örneği: .NET Core WinForms Biçimlendirme Yardımcı Programı (Visual Basic)