Byte Yapı

Tanım

8 bit işaretsiz tamsayıyı temsil eder.Represents an 8-bit unsigned integer.

public value class Byte : IComparable, IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, IFormattable
public value class Byte : IComparable, IConvertible, IFormattable
public value class Byte : IComparable, IComparable<System::Byte>, IEquatable<System::Byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
[System.Serializable]
public struct Byte : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IEquatable<byte>, IFormattable
type byte = struct
    interface IConvertible
    interface IFormattable
[<System.Serializable>]
type byte = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type byte = struct
    interface IFormattable
    interface IConvertible
type byte = struct
    interface IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IConvertible, IEquatable(Of Byte), IFormattable
Public Structure Byte
Implements IComparable, IConvertible, IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IEquatable(Of Byte), IFormattable
Devralma
Öznitelikler
Uygulamalar

Açıklamalar

Byte , 0 ' dan (Constant tarafından temsil edilen Byte.MinValue ) 255 (sabiti tarafından temsil edilir) arasında bir değer içeren işaretsiz tamsayılar temsil eden sabit bir değer türüdür Byte.MaxValue .Byte is an immutable value type that represents unsigned integers with values that range from 0 (which is represented by the Byte.MinValue constant) to 255 (which is represented by the Byte.MaxValue constant). .NET ayrıca, SByte -128 ile 127 arasında bir değer temsil eden işaretli 8 bitlik bir tamsayı değer türü içerir..NET also includes a signed 8-bit integer value type, SByte, which represents values that range from -128 to 127.

Bir Bayt Değerini ÖrneklemeInstantiating a Byte Value

ByteBirkaç şekilde bir değer örneği oluşturabilirsiniz:You can instantiate a Byte value in several ways:

  • Bir Byte değişken bildirebilir ve onu veri türü aralığı içinde olan bir sabit tamsayı değeri atayabilirsiniz Byte .You can declare a Byte variable and assign it a literal integer value that is within the range of the Byte data type. Aşağıdaki örnek iki değişken bildirir Byte ve bu şekilde değerleri atar.The following example declares two Byte variables and assigns them values in this way.

    byte value1 = 64;
    byte value2 = 255;
    
    Dim value1 As Byte = 64
    Dim value2 As Byte = 255
    
  • Bayta bayt olmayan bir sayısal değer atayabilirsiniz.You can assign a non-byte numeric value to a byte. Bu bir daraltma dönüştürmesidir, bu nedenle C# dilinde bir atama işleci ve açık ise Visual Basic bir dönüştürme yöntemi gerektirir Option Strict .This is a narrowing conversion, so it requires a cast operator in C# and a conversion method in Visual Basic if Option Strict is on. Bayt olmayan değer bir Single , Double veya Decimal kesirli bir bileşen içeren bir değer ise, kesirli bölümünün işlenmesi dönüştürme gerçekleştiren derleyiciye bağlıdır.If the non-byte value is a Single, Double, or Decimal value that includes a fractional component, the handling of its fractional part depends on the compiler performing the conversion. Aşağıdaki örnek, değişkenlere birkaç sayısal değer atar Byte .The following example assigns several numeric values to Byte variables.

    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
    
    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
    
  • ConvertDesteklenen herhangi bir türü bir değere dönüştürmek için sınıfının bir yöntemini çağırabilirsiniz Byte .You can call a method of the Convert class to convert any supported type to a Byte value. Bu, Byte arabirimini desteklediğinden mümkündür IConvertible .This is possible because Byte supports the IConvertible interface. Aşağıdaki örnek değerlere bir değer dizisinin dönüştürülmesini gösterir Int32 Byte .The following example illustrates the conversion of an array of Int32 values to Byte values.

    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.
    
    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 Bir değerin dize gösterimini ' a dönüştürmek için veya metodunu çağırabilirsiniz Byte Byte .You can call the Parse or TryParse method to convert the string representation of a Byte value to a Byte. Dize, ondalık ya da onaltılık basamaklar içerebilir.The string can contain either decimal or hexadecimal digits. Aşağıdaki örnek, bir Decimal ve onaltılı dize kullanarak Ayrıştırma işlemini gösterir.The following example illustrates the parse operation by using both a decimal and a hexadecimal string.

    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
    
    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ğerleri Üzerinde İşlem GerçekleştirmePerforming Operations on Byte Values

ByteTür, toplama, çıkarma, bölme, çarpma, çıkarma, olumsuzlama ve birli olumsuzlama gibi standart matematik işlemlerini destekler.The Byte type supports standard mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. Diğer integral türleri gibi, Byte tür de bit düzeyinde AND , OR , XOR , sol SHIFT ve sağ SHIFT işleçlerini da destekler.Like the other integral types, the Byte type also supports the bitwise AND, OR, XOR, left shift, and right shift operators.

İki değeri karşılaştırmak için standart sayısal işleçleri kullanabilir Byte veya CompareTo ya da yöntemini çağırabilirsiniz Equals .You can use the standard numeric operators to compare two Byte values, or you can call the CompareTo or Equals method.

Ayrıca, Math bir sayının mutlak değerini alma, tam sayı bölümünden bölümü ve kalanı hesaplama, iki tamsayının en büyük veya en küçük değerini belirleme, bir sayının işaretini alma ve bir sayıyı yuvarlama dahil olmak üzere çok çeşitli sayısal işlemleri gerçekleştirmek için, sınıfın üyelerini çağırabilirsiniz.You can also call the members of the Math class to perform a wide range of numeric operations, including getting the absolute value of a number, calculating the quotient and remainder from integral division, determining the maximum or minimum value of two integers, getting the sign of a number, and rounding a number.

Bir Baytı Dize Olarak Temsil EtmeRepresenting a Byte as a String

ByteTürü, standart ve özel sayısal biçim dizeleri için tam destek sağlar.The Byte type provides full support for standard and custom numeric format strings. (Daha fazla bilgi için bkz. biçimlendirme türleri, Standart sayısal biçim dizelerive özel sayısal biçim dizeleri.) Ancak, en yaygın olarak, bayt değerleri ek biçimlendirme olmadan veya iki basamaklı onaltılık değerler olmadan üç basamaklı bir değer olarak temsil edilir.(For more information, see Formatting Types, Standard Numeric Format Strings, and Custom Numeric Format Strings.) However, most commonly, byte values are represented as one-digit to three-digit values without any additional formatting, or as two-digit hexadecimal values.

Bir Byte değeri, önünde sıfır olmayan bir integral dize olarak biçimlendirmek için parametresiz ToString() yöntemi çağırabilirsiniz.To format a Byte value as an integral string with no leading zeros, you can call the parameterless ToString() method. "D" biçim belirticisini kullanarak, dize gösteriminde belirtilen bir dizi baştaki sıfırları de dahil edebilirsiniz.By using the "D" format specifier, you can also include a specified number of leading zeros in the string representation. "X" biçim belirticisini kullanarak bir Byte değeri onaltılık bir dize olarak temsil edebilirsiniz.By using the "X" format specifier, you can represent a Byte value as a hexadecimal string. Aşağıdaki örnek, Byte Bu üç şekilde bir değer dizisindeki öğeleri biçimlendirir.The following example formats the elements in an array of Byte values in these three ways.

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
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

Ayrıca Byte , ToString(Byte, Int32) yöntemini çağırarak ve yöntemin ikinci parametresi olarak temeli sağlayarak bir değeri ikili, sekizlik, Decimal veya onaltılı dize olarak biçimlendirebilirsiniz.You can also format a Byte value as a binary, octal, decimal, or hexadecimal string by calling the ToString(Byte, Int32) method and supplying the base as the method's second parameter. Aşağıdaki örnek, bir bayt değerleri dizisinin ikili, sekizlik ve onaltılı gösterimlerini göstermek için bu yöntemi çağırır.The following example calls this method to display the binary, octal, and hexadecimal representations of an array of byte values.

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
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ğerleri ile ÇalışmaWorking with Non-Decimal Byte Values

Tek tek baytlarla birlikte ondalık değerler olarak çalışmanın yanı sıra, bayt değerleriyle bit düzeyinde işlemler gerçekleştirmek veya bayt dizileri ile ya da bayt değerlerinin ikili veya onaltılı gösterimlerine göre çalışmak isteyebilirsiniz.In addition to working with individual bytes as decimal values, you may want to perform bitwise operations with byte values, or work with byte arrays or with the binary or hexadecimal representations of byte values. Örneğin, yönteminin aşırı yüklemeleri BitConverter.GetBytes ilkel veri türlerinin her birini bir bayt dizisine dönüştürebilir ve BigInteger.ToByteArray yöntemi bir BigInteger değeri bayt dizisine dönüştürür.For example, overloads of the BitConverter.GetBytes method can convert each of the primitive data types to a byte array, and the BigInteger.ToByteArray method converts a BigInteger value to a byte array.

Byte değerler, bir işaret biti olmadan yalnızca büyüklüğüne göre 8 bit olarak temsil edilir.Byte values are represented in 8 bits by their magnitude only, without a sign bit. Bu, değerler üzerinde bit düzeyinde işlemler gerçekleştirirken Byte veya tek tek bitler ile çalışırken göz önünde bulundurmanız önemlidir.This is important to keep in mind when you perform bitwise operations on Byte values or when you work with individual bits. 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.In order to perform a numeric, Boolean, or comparison operation on any two non-decimal values, both values must use the same representation.

İki değer üzerinde bir işlem gerçekleştirildiğinde Byte , değerler aynı gösterimi paylaşır, bu nedenle sonuç doğru olur.When an operation is performed on two Byte values, the values share the same representation, so the result is accurate. Bu, bir değerin en düşük sıra bitini maskelerin eşit olduğundan emin olmak için, aşağıdaki örnekte gösterilmiştir Byte .This is illustrated in the following example, which masks the lowest-order bit of a Byte value to ensure that it is even.

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
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

Öte yandan, hem imzasız hem de imzalı bitler ile çalışırken, bit düzeyinde işlemler, SByte değerlerin pozitif değerler için oturum açma ve büyüklük gösterimini ve negatif değerler için iki tamamlama gösterimini kullanmasını gerçekten karmaşıktır.On the other hand, when you work with both unsigned and signed bits, bitwise operations are complicated by the fact that the SByte values use sign-and-magnitude representation for positive values, and two's complement representation for negative values. Anlamlı bit düzeyinde bir işlem gerçekleştirmek için değerler iki eşdeğer temsilye dönüştürülmelidir ve işaret biti ile ilgili bilgilerin korunması gerekir.In order to perform a meaningful bitwise operation, the values must be converted to two equivalent representations, and information about the sign bit must be preserved. Aşağıdaki örnek, 8 bitlik imzalı ve işaretsiz değerlerin bir dizisinin 2. ve 4. kısmını maskelemek için bunu yapar.The following example does this to mask out bits 2 and 4 of an array of 8-bit signed and unsigned values.

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)
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)

Alanlar

MaxValue

Olası en büyük değerini temsil eder Byte .Represents the largest possible value of a Byte. Bu alan sabittir.This field is constant.

MinValue

Mümkün olan en küçük değeri temsil eder Byte .Represents the smallest possible value of a Byte. Bu alan sabittir.This field is constant.

Yöntemler

CompareTo(Byte)

Bu örneği belirtilen 8 bit işaretsiz bir tamsayı ile karşılaştırır ve göreli değerlerinin bir göstergesini döndürür.Compares this instance to a specified 8-bit unsigned integer and returns an indication of their relative values.

CompareTo(Object)

Bu örneği belirtilen nesne ile karşılaştırır ve göreli değerlerin bir göstergesini döndürür.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Byte)

Bu örneğin ve belirtilen Byte nesnenin aynı değeri gösterip göstermediğini gösteren bir değer döndürür.Returns a value indicating whether this instance and a specified Byte object represent the same value.

Equals(Object)

Bu örneğin, belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.Returns the hash code for this instance.

GetTypeCode()

TypeCodeDeğer türünü döndürür Byte .Returns the TypeCode for value type Byte.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Belirtilen bir stilin ve kültüre özgü biçimdeki bir sayının span gösterimini Byte eşdeğerine dönüştürür.Converts the span representation of a number in a specified style and culture-specific format to its Byte equivalent.

Parse(String)

Bir sayının dize gösterimini Byte eşdeğerine dönüştürür.Converts the string representation of a number to its Byte equivalent.

Parse(String, IFormatProvider)

Belirli bir kültüre özgü biçimdeki bir sayının dize gösterimini Byte eşdeğerine dönüştürür.Converts the string representation of a number in a specified culture-specific format to its Byte equivalent.

Parse(String, NumberStyles)

Belirtilen bir stildeki bir sayının dize gösterimini Byte eşdeğerine dönüştürür.Converts the string representation of a number in a specified style to its Byte equivalent.

Parse(String, NumberStyles, IFormatProvider)

Belirtilen bir stilin ve kültüre özgü biçimdeki bir sayının dize gösterimini Byte eşdeğerine dönüştürür.Converts the string representation of a number in a specified style and culture-specific format to its Byte equivalent.

ToString()

Geçerli Byte nesnenin değerini eşdeğer dize gösterimine dönüştürür.Converts the value of the current Byte object to its equivalent string representation.

ToString(IFormatProvider)

Geçerli nesnenin sayısal değerini, Byte belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.Converts the numeric value of the current Byte object to its equivalent string representation using the specified culture-specific formatting information.

ToString(String)

Geçerli nesnenin değerini, Byte belirtilen biçimi kullanarak eşdeğer dize gösterimine dönüştürür.Converts the value of the current Byte object to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Geçerli nesnenin değerini, Byte belirtilen biçimi ve kültüre özgü biçimlendirme bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.Converts the value of the current Byte object to its equivalent string representation using the specified format and culture-specific formatting information.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Geçerli 8 bit işaretsiz tamsayı örneğinin değerini, belirtilen karakter aralığına biçimlendirmeye çalışır.Tries to format the value of the current 8-bit unsigned integer instance into the provided span of characters.

TryParse(ReadOnlySpan<Char>, Byte)

Bir sayının span gösterimini eşdeğerine dönüştürmeye çalışır Byte ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.Tries to convert the span representation of a number to its Byte equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)

Belirtilen bir stilin ve kültüre özgü biçimdeki bir sayının span gösterimini Byte eşdeğerine dönüştürür.Converts the span representation of a number in a specified style and culture-specific format to its Byte equivalent. Dönüştürmenin başarılı veya başarısız olduğunu gösteren dönüş değeri.A return value indicates whether the conversion succeeded or failed.

TryParse(String, Byte)

Bir sayının dize gösterimini eşdeğerine dönüştürmeye çalışır Byte ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.Tries to convert the string representation of a number to its Byte equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, Byte)

Belirtilen bir stilin ve kültüre özgü biçimdeki bir sayının dize gösterimini Byte eşdeğerine dönüştürür.Converts the string representation of a number in a specified style and culture-specific format to its Byte equivalent. Dönüştürmenin başarılı veya başarısız olduğunu gösteren dönüş değeri.A return value indicates whether the conversion succeeded or failed.

Belirtik Arabirim Kullanımları

IComparable.CompareTo(Object)

Mevcut örneği aynı türdeki başka bir nesne ile karşılaştırır ve geçerli örneğin, diğer nesneyle aynı sıralama düzeni konumunda mı olduğunu, önünde mi olduğunu, yoksa arkasında mı olduğunu belirten bir tamsayı döndürür.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

IConvertible.GetTypeCode()

TypeCodeBu örnek için döndürür.Returns the TypeCode for this instance.

IConvertible.ToBoolean(IFormatProvider)

Bu üyenin açıklaması için bkz ToBoolean(IFormatProvider) ..For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Bu üyenin açıklaması için bkz ToByte(IFormatProvider) ..For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Bu üyenin açıklaması için bkz ToChar(IFormatProvider) ..For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Bu dönüşüm desteklenmiyor.This conversion is not supported. Bu yöntemi kullanma girişimi bir oluşturur InvalidCastException .Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

Bu üyenin açıklaması için bkz ToDecimal(IFormatProvider) ..For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Bu üyenin açıklaması için bkz ToDouble(IFormatProvider) ..For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Bu üyenin açıklaması için bkz ToInt16(IFormatProvider) ..For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Bu üyenin açıklaması için bkz ToInt32(IFormatProvider) ..For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Bu üyenin açıklaması için bkz ToInt64(IFormatProvider) ..For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Bu üyenin açıklaması için bkz ToSByte(IFormatProvider) ..For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Bu üyenin açıklaması için bkz ToSingle(IFormatProvider) ..For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Bu üyenin açıklaması için bkz ToType(Type, IFormatProvider) ..For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Bu üyenin açıklaması için bkz ToUInt16(IFormatProvider) ..For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Bu üyenin açıklaması için bkz ToUInt32(IFormatProvider) ..For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Bu üyenin açıklaması için bkz ToUInt64(IFormatProvider) ..For a description of this member, see ToUInt64(IFormatProvider).

Şunlara uygulanır

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

Bu türün tüm üyeleri iş parçacığı güvenlidir.All members of this type are thread safe. Örneğin durumunu değiştirmek için görüntülenen üyeler, gerçekte yeni değer ile başlatılan yeni bir örneği döndürür.Members that appear to modify instance state actually return a new instance initialized with the new value. Diğer türlerde olduğu gibi, bu türün örneğini içeren paylaşılan değişkenini okuma ve yazma, iş parçacığı güvenliğini sağlamak için bir kilit tarafından korunmalıdır.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

Ayrıca bkz.