Byte Struktura

Definice

Představuje 8bitovou verzi unsigned integer.

public value class System::Byte : IComparable, IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, IFormattable
public value class System::Byte : IComparable, IComparable<System::Byte>, IConvertible, IEquatable<System::Byte>, ISpanFormattable
public value class System::Byte : IComparable, IConvertible, IFormattable
public value class System::Byte : IComparable, IComparable<System::Byte>, IEquatable<System::Byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, ISpanFormattable
[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
type byte = struct
    interface IConvertible
    interface ISpanFormattable
    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, IComparable(Of Byte), IConvertible, IEquatable(Of Byte), ISpanFormattable
Public Structure Byte
Implements IComparable, IConvertible, IFormattable
Public Structure Byte
Implements IComparable, IComparable(Of Byte), IEquatable(Of Byte), IFormattable
Dědičnost
Atributy
Implementuje

Poznámky

Byte je neměnný hodnotový typ, který představuje celá čísla bez znaménka s hodnotami v rozsahu od 0 (která je reprezentována konstantou) do 255 (která je reprezentována Byte.MinValue Byte.MaxValue konstantou). .NET obsahuje také typ hodnoty se znaménkem 8bitového celého čísla, který představuje hodnoty v rozsahu SByte od -128 do 127.

Vytvoření instance bajtové hodnoty

Instanci hodnoty můžete vytvořit Byte několika způsoby:

  • Můžete deklarovat proměnnou a přiřadit ji literálovou celočíselnou hodnotu, která je Byte v rozsahu Byte datového typu. Následující příklad deklaruje Byte dvě proměnné a přiřadí jim hodnoty tímto způsobem.

    byte value1 = 64;
    byte value2 = 255;
    
    let value1 = 64uy
    let value2 = 255uy
    
    Dim value1 As Byte = 64
    Dim value2 As Byte = 255
    
  • K byte můžete přiřadit ne bytetovou číselnou hodnotu. Jedná se o zužující převod, takže vyžaduje operátor přetypování v jazyce C# a F#, nebo metodu převodu v Visual Basic, pokud Option Strict je na. Pokud je hodnota bez desetinných hodnot , nebo , která obsahuje zlomkovou komponentu, zpracování zlomkové části závisí na kompilátoru Single Double Decimal provádějícím převod. Následující příklad přiřadí proměnné několik Byte číselných hodnot.

    int int1 = 128;
    try {
       byte value1 = (byte) int1;
       Console.WriteLine(value1);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of a byte.", int1);
    }
    
    double dbl2 = 3.997;
    try {
       byte value2 = (byte) dbl2;
       Console.WriteLine(value2);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of a byte.", dbl2);
    }
    // The example displays the following output:
    //       128
    //       3
    
    let int1 = 128
    try
        let value1 = byte int1
        printfn $"{value1}"
    with :? OverflowException ->
        printfn $"{int1} is out of range of a byte."
    
    let dbl2 = 3.997
    try
        let value2 = byte dbl2
        printfn $"{value2}"
    with :? OverflowException ->
        printfn $"{dbl2} is out of range of a byte."
    
    // The example displays the following output:
    //       128
    //       3
    
    Dim int1 As Integer = 128
    Try
       Dim value1 As Byte = CByte(int1)
       Console.WriteLine(value1)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of a byte.", int1)
    End Try
    
    Dim dbl2 As Double = 3.997
    Try
       Dim value2 As Byte = CByte(dbl2)
       Console.WriteLine(value2)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of a byte.", dbl2)
    End Try   
    ' The example displays the following output:
    '       128
    '       4
    
  • Můžete volat metodu třídy Convert pro převod libovolného podporovaného typu na Byte hodnotu. To je možné, Byte protože podporuje IConvertible rozhraní . Následující příklad znázorňuje převod pole hodnot Int32 na Byte hodnoty.

    int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
    byte result;
    foreach (int number in numbers)
    {
       try {
          result = Convert.ToByte(number);
          Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                            number.GetType().Name, number,
                            result.GetType().Name, result);
       }
       catch (OverflowException) {
          Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                            number.GetType().Name, number);
       }
    }
    // The example displays the following output:
    //       The Int32 value -2147483648 is outside the range of the Byte type.
    //       The Int32 value -1 is outside the range of the Byte type.
    //       Converted the Int32 value 0 to the Byte value 0.
    //       Converted the Int32 value 121 to the Byte value 121.
    //       The Int32 value 340 is outside the range of the Byte type.
    //       The Int32 value 2147483647 is outside the range of the Byte type.
    
    open System
    
    let numbers = [| Int32.MinValue; -1; 0; 121; 340; Int32.MaxValue |]
    
    for number in numbers do
        try
            let result = Convert.ToByte number
            printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
    
        with :? OverflowException ->
            printfn $"The {number.GetType().Name} value {number} is outside the range of the Byte type."
    
    
    // The example displays the following output:
    //       The Int32 value -2147483648 is outside the range of the Byte type.
    //       The Int32 value -1 is outside the range of the Byte type.
    //       Converted the Int32 value 0 to the Byte value 0.
    //       Converted the Int32 value 121 to the Byte value 121.
    //       The Int32 value 340 is outside the range of the Byte type.
    //       The Int32 value 2147483647 is outside the range of the Byte type.
    
    Dim numbers() As Integer = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue }
    Dim result As Byte
    For Each number As Integer In numbers
       Try
          result = Convert.ToByte(number)
          Console.WriteLIne("Converted the {0} value {1} to the {2} value {3}.", _
                            number.GetType().Name, number, _
                            result.GetType().Name, result)
       Catch e As OverflowException
          Console.WriteLine("The {0} value {1} is outside the range of the Byte type.", _
                            number.GetType().Name, number)
       End Try
    Next
    ' The example displays the following output:
    '       The Int32 value -2147483648 is outside the range of the Byte type.
    '       The Int32 value -1 is outside the range of the Byte type.
    '       Converted the Int32 value 0 to the Byte value 0.
    '       Converted the Int32 value 121 to the Byte value 121.
    '       The Int32 value 340 is outside the range of the Byte type.
    '       The Int32 value 2147483647 is outside the range of the Byte type.
    
  • Můžete volat Parse metodu nebo TryParse a převést řetězcovou reprezentaci Byte hodnoty na Byte . Řetězec může obsahovat desítkové nebo šestnáctkové číslice. Následující příklad znázorňuje operaci parsování pomocí desetinného i šestnáctkového řetězce.

    string string1 = "244";
    try {
       byte byte1 = Byte.Parse(string1);
       Console.WriteLine(byte1);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string1);
    }
    catch (FormatException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string1);
    }
    
    string string2 = "F9";
    try {
       byte byte2 = Byte.Parse(string2,
                               System.Globalization.NumberStyles.HexNumber);
       Console.WriteLine(byte2);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string2);
    }
    catch (FormatException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string2);
    }
    // The example displays the following output:
    //       244
    //       249
    
    let string1 = "244"
    try
        let byte1 = Byte.Parse string1
        printfn $"{byte1}" 
    with
    | :? OverflowException ->
        printfn $"'{string1}' is out of range of a byte."
    | :? FormatException ->
        printfn $"'{string1}' is out of range of a byte."
    
    let string2 = "F9"
    try
        let byte2 = Byte.Parse(string2, System.Globalization.NumberStyles.HexNumber)
        printfn $"{byte2}"
    with
    | :? OverflowException ->
        printfn $"'{string2}' is out of range of a byte."
    | :? FormatException ->
        printfn $"'{string2}' is out of range of a byte."
    
    // The example displays the following output:
    //       244
    //       249
    
    Dim string1 As String = "244"
    Try
       Dim byte1 As Byte = Byte.Parse(string1)
       Console.WriteLine(byte1)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a byte.", string1)
    Catch e As FormatException
       Console.WriteLine("'{0}' is out of range of a byte.", string1)
    End Try
    
    Dim string2 As String = "F9"
    Try
       Dim byte2 As Byte = Byte.Parse(string2,
                                 System.Globalization.NumberStyles.HexNumber)
       Console.WriteLine(byte2)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a byte.", string2)
    Catch e As FormatException
       Console.WriteLine("'{0}' is out of range of a byte.", string2)
    End Try
    ' The example displays the following output:
    '       244
    '       249
    

Provádění operací na bajtových hodnotách

Typ podporuje standardní matematické operace, jako je sčítání, odčítání, Byte dělení, násobení, odčítání, negace a unární negace. Stejně jako ostatní celočíselné typy Byte podporuje i typ bitové operátory , , , posun doleva a AND posun OR XOR doprava.

Standardní číselné operátory můžete použít k porovnání dvou Byte hodnot nebo můžete volat CompareTo metodu nebo Equals .

Můžete také volat členy třídy k provedení širokého rozsahu číselných operací, včetně získání absolutní hodnoty čísla, výpočtu podílu a zbytku od celočíselného dělení, určení maximální nebo minimální hodnoty dvou celých čísel, získání znaménka čísla a zaokrouhlení Math čísla.

Znázornění bajtu jako řetězce

Typ Byte poskytuje plnou podporu pro standardní a vlastní řetězce číselného formátu. (Další informace najdete v tématu Typy formátování, Standardní řetězce číselného formátua Vlastní řetězce číselného formátu.) Nejčastěji jsou však hodnoty byte reprezentovány jako jednociferné až třímístné hodnoty bez dalšího formátování nebo jako dvouciferné šestnáctkové hodnoty.

Pokud chcete Byte naformátovat hodnotu jako celočíselné řetězce bez úvodních nul, můžete volat metodu bez ToString() parametrů. Pomocí specifikátoru formátu "D" můžete do řetězcové reprezentace zahrnout také zadaný počet úvodních nul. Pomocí specifikátoru formátu "X" můžete hodnotu reprezentovat Byte jako šestnáctkový řetězec. Následující příklad formátuje prvky v poli Byte hodnot těmito třemi způsoby.

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

Hodnotu můžete také naformátovat jako binární, osmičkový, desítkový nebo šestnáctkový řetězec voláním metody a poskytnutím základu jako druhého parametru Byte ToString(Byte, Int32) metody. Následující příklad volá tuto metodu k zobrazení binární, osmičkové a šestnáctkové reprezentace pole hodnot bajtů.

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

Práce s bajtovými hodnotami bez desetinných hodnot

Kromě práce s jednotlivými bajty jako s desetinnými hodnotami můžete chtít provádět bitové operace s bajtovými hodnotami, pracovat s bajtovými poli nebo s binárními či šestnáctkovými reprezentacemi bajtových hodnot. Například přetížení metody může převést každý z primitivních datových typů na pole bajtů a metoda převede hodnotu BitConverter.GetBytes BigInteger.ToByteArray na pole BigInteger bajtů.

Byte Hodnoty jsou reprezentovány pouze v 8 bitech jejich velikostí, bez bitu znaménka. To je důležité mít na paměti při provádění bitových operací s hodnotami nebo při práci Byte s jednotlivými bity. Aby bylo možné provést číselnou, logickou nebo srovnávací operaci se dvěma ne desetinnými hodnotami, musí obě hodnoty používat stejnou reprezentaci.

Při provedení operace se dvěma hodnotami mají hodnoty stejnou Byte reprezentaci, takže výsledek je přesný. To je znázorněno v následujícím příkladu, který maskuje bit nejnižšího pořadí hodnoty, aby se zajistilo, že Byte je rovnoměrně.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { Convert.ToString(12, 16),
                          Convert.ToString(123, 16),
                          Convert.ToString(245, 16) };

      byte mask = 0xFE;
      foreach (string value in values) {
         Byte byteValue = Byte.Parse(value, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("{0} And {1} = {2}", byteValue, mask,
                           byteValue & mask);
      }
   }
}
// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244
open System
open System.Globalization

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

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

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

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

Při práci s bity bez znaménka i se znaménkem jsou bitové operace naopak komplikované skutečností, že hodnoty používají znaménkové a magnitudové vyjádření pro kladné hodnoty a dvě doplňující reprezentace pro SByte záporné hodnoty. Aby bylo možné provést smysluplnou bitovou operaci, musí být hodnoty převedeny na dvě ekvivalentní reprezentace a informace o bitu znaménka musí být zachovány. Následující příklad zamaskuje bity 2 a 4 pole 8bitových hodnot se znaménkem a bez znaménka.

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

Pole

MaxValue

Představuje největší možnou hodnotu Byte . Toto pole je konstantní.

MinValue

Představuje nejmenší možnou hodnotu Byte . Toto pole je konstantní.

Metody

CompareTo(Byte)

Porovná tuto instanci se zadanou 8bitovou unsigned integer a vrátí indikaci jejich relativních hodnot.

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.

Equals(Byte)

Vrátí hodnotu určující, zda tato instance a zadaný Byte objekt představují stejnou hodnotu.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

GetTypeCode()

Vrátí pro TypeCode typ hodnoty Byte .

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentaci span čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho Byte ekvivalent.

Parse(String)

Převede řetězcové vyjádření čísla na jeho Byte ekvivalent.

Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho Byte ekvivalent.

Parse(String, NumberStyles)

Převede řetězcové vyjádření čísla v zadaném stylu na jeho Byte ekvivalent.

Parse(String, NumberStyles, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho Byte ekvivalent.

ToString()

Převede hodnotu aktuálního objektu na jeho Byte ekvivalentní řetězcové vyjádření.

ToString(IFormatProvider)

Převede číselnou hodnotu aktuálního objektu na ekvivalentní řetězcovou reprezentaci pomocí zadaných informací o formátování Byte specifických pro jazykovou verzi.

ToString(String)

Převede hodnotu aktuálního objektu na jeho ekvivalentní Byte řetězcové vyjádření pomocí zadaného formátu.

ToString(String, IFormatProvider)

Převede hodnotu aktuálního objektu na ekvivalentní řetězcovou reprezentaci pomocí zadaného formátu a informací o formátování Byte specifických pro jazykovou verzi.

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

Pokusí se naformátovat hodnotu aktuální 8bitové instance unsigned integer do zadaného rozsahu znaků.

TryParse(ReadOnlySpan<Char>, Byte)

Pokusí se převést rozsah reprezentující číslo na jeho Byte ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.

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

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na jeho Byte ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

TryParse(String, Byte)

Pokusí se převést řetězcové vyjádření čísla na jeho Byte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

TryParse(String, NumberStyles, IFormatProvider, Byte)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na jeho Byte ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo udávající, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejné pozici v pořadí řazení jako druhý objekt.

IConvertible.GetTypeCode()

Vrátí hodnotu TypeCode pro tuto instanci.

IConvertible.ToBoolean(IFormatProvider)

Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider) .

IConvertible.ToByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToByte(IFormatProvider) .

IConvertible.ToChar(IFormatProvider)

Popis tohoto člena naleznete v tématu ToChar(IFormatProvider) .

IConvertible.ToDateTime(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToDecimal(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider) .

IConvertible.ToDouble(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider) .

IConvertible.ToInt16(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider) .

IConvertible.ToInt32(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider) .

IConvertible.ToInt64(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider) .

IConvertible.ToSByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider) .

IConvertible.ToSingle(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider) .

IConvertible.ToType(Type, IFormatProvider)

Popis tohoto člena najdete v tématu ToType(Type, IFormatProvider) .

IConvertible.ToUInt16(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt16(IFormatProvider) .

IConvertible.ToUInt32(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt32(IFormatProvider) .

IConvertible.ToUInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt64(IFormatProvider) .

Platí pro

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.

Viz také