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.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
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
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, işaretsiz tamsayıları temsil eden, 0 ' dan (Byte.MinValue sabiti ile temsil edilen) 255 (Byte.MaxValue sabiti tarafından temsil edilir) arasında değer içeren işaretsiz tamsayılar temsil eden sabit bir değer türüdür.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 Framework Ayrıca,-128 ile 127 arasında bir değer olan değerleri temsil eden, işaretli bir 8 bit tamsayı değer türü de içerir SByte.The .NET Framework 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

Byte bir değeri birkaç yolla oluşturabilirsiniz:You can instantiate a Byte value in several ways:

  • Bir Byte değişkeni bildirebilir ve bunu Byte veri türünün aralığı içinde olan bir sabit tamsayı değeri atayabilirsiniz.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 Byte değişken bildirir 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 içinde C# bir atama işleci ve Option Strict açık ise Visual Basic bir dönüştürme yöntemi gerektirir.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, Doubleveya kesirli bir bileşen içeren Decimal değeri 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 Byte değişkenlerine birkaç sayısal değer atar.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
    
  • Desteklenen herhangi bir türü Byte bir değere dönüştürmek için Convert sınıfının bir yöntemini çağırabilirsiniz.You can call a method of the Convert class to convert any supported type to a Byte value. Bu, Byte IConvertible arabirimini desteklediğinden mümkündür.This is possible because Byte supports the IConvertible interface. Aşağıdaki örnek, Int32 değerleri dizisinin Byte değerlerine dönüştürülmesini gösterir.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.      
    
  • Byte değerin dize gösterimini Bytedönüştürmek için Parse veya TryParse yöntemini çağırabilirsiniz.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

Byte tü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 destekler.Like the other integral types, the Byte type also supports the bitwise AND, OR, XOR, left shift, and right shift operators.

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

Ayrıca, bir sayının mutlak değerini alma, tam sayı bölümünden bölümü ve kalanı hesaplama, en büyük veya en küçük değeri belirleme, bir sayının işaretini alma ve bir sayıyı yuvarlama dahil olmak üzere çok sayıda sayısal işlem gerçekleştirmek için Math sınıfını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

Byte tü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ğerini, önünde sıfır olmadan bir integral dize olarak biçimlendirmek için parametresiz ToString() yöntemini ç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ğerini 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 değerleri dizisindeki öğeleri bu üç şekilde 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, ToString(Byte, Int32) yöntemini çağırarak ve yöntemin ikinci parametresi olarak temeli sağlayarak bir Byte değerini 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, BitConverter.GetBytes yönteminin aşırı yüklemeleri, ilkel veri türlerinin her birini bir bayt dizisine dönüştürebilir ve BigInteger.ToByteArray yöntemi bir BigInteger değerini bir 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üğü 8 bit ile temsil edilir.Byte values are represented in 8 bits by their magnitude only, without a sign bit. Bu, Byte değerlerinde veya tek tek bitlerle çalışırken bit düzeyinde işlemler gerçekleştirirken 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 Byte değer üzerinde bir işlem gerçekleştirildiğinde, 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, Çift olduğundan emin olmak için bir Byte değerinin en düşük sıra bitini maskeden aşağıdaki örnekte gösterilmiştir.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ğerlerinin 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ından 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

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

MinValue

Byteen küçük olası değeri temsil eder.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 nesnesinin 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()

Değer türü Byteiçin TypeCode döndürür.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 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 stil 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 nesnesinin 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 Byte nesnesinin sayısal değerini, 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 Byte nesnesinin değerini, 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 Byte nesnesinin değerini, 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 Byte eşdeğerine 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.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 Byte eşdeğerine 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.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 stil 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)
IConvertible.GetTypeCode()
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 InvalidCastExceptionoluşturur.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.