Byte.TryParse Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: netstandard.dll

Sestavení:: mscorlib.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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

Přetížení

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Pokusí se parsovat rozsah znaků UTF-8 na hodnotu.
TryParse(ReadOnlySpan<Char>, Byte)	Pokusí se převést reprezentaci rozsahu čísla na jeho Byte ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.
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(ReadOnlySpan<Char>, IFormatProvider, Byte)	Pokusí se parsovat rozsah znaků na hodnotu.
TryParse(String, IFormatProvider, Byte)	Pokusí se parsovat řetězec na hodnotu.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Pokusí se parsovat rozsah znaků UTF-8 na hodnotu.
TryParse(ReadOnlySpan<Byte>, Byte)	Pokusí se převést znakový rozsah UTF-8 obsahující řetězcové vyjádření čísla na jeho 8bitový celočíselný ekvivalent bez znaménka.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho Byte ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho Byte ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se parsovat rozsah znaků UTF-8 na hodnotu.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = IUtf8SpanParsable<System::Byte>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametry

utf8Text: ReadOnlySpan<Byte>

Rozsah znaků UTF-8, které se mají analyzovat.

provider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro utf8Textjazykovou verzi.

result: Byte

Při vrácení obsahuje výsledek úspěšné analýzy utf8Text nebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud utf8Text byl úspěšně parsován, jinak hodnota false.

Platí pro

TryParse(ReadOnlySpan<Char>, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

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

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse (ReadOnlySpan<char> s, out byte result);

static member TryParse : ReadOnlySpan<char> * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Byte) As Boolean

Parametry

s: ReadOnlySpan<Char>

Rozsah obsahující znaky představující číslo, které se má převést.

result: Byte

Když tato metoda vrátí hodnotu Byte odpovídající číslu obsaženému v s případě úspěšného převodu, nebo nulu, pokud se převod nezdařil. Tento parametr je předán neinicializován; jakákoli hodnota původně zadaná v result bude přepsána.

Návraty

Boolean

true pokud s byl úspěšně převeden, jinak hodnota false.

Platí pro

TryParse(String, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

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

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse (string s, out byte result);

public static bool TryParse (string? s, out byte result);

static member TryParse : string * byte -> bool

Public Shared Function TryParse (s As String, ByRef result As Byte) As Boolean

Parametry

s: String

Řetězec obsahující číslo k převedení.

result: Byte

Návraty

Boolean

true pokud s byl úspěšně převeden, jinak hodnota false.

Příklady

Následující příklad volá metodu TryParse(String, Byte) s několika různými řetězcovými hodnotami.

using namespace System;

void main()
{
   array<String^>^ byteStrings = gcnew array<String^> { nullptr, String::Empty, 
                                                        "1024", "100.1", "100", 
                                                        "+100", "-100", "000000000000000100", 
                                                        "00,100", "   20   ", "FF", "0x1F" };
   Byte byteValue;
   for each (String^ byteString in byteStrings) {
      bool result = Byte::TryParse(byteString, byteValue);
      if (result)
         Console::WriteLine("Converted '{0}' to {1}", 
                            byteString, byteValue);
      else
         Console::WriteLine("Attempted conversion of '{0}' failed.", 
                            byteString);
   }
}
// The example displays the following output:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.`
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.}

using System;

public class ByteConversion
{
   public static void Main()
   {
      string[] byteStrings = { null, string.Empty, "1024",
                               "100.1", "100", "+100", "-100",
                               "000000000000000100", "00,100",
                               "   20   ", "FF", "0x1F" };

      foreach (var byteString in byteStrings)
      {
          CallTryParse(byteString);
      }
   }

   private static void CallTryParse(string stringToConvert)
   {
      byte byteValue;
      bool success = Byte.TryParse(stringToConvert, out byteValue);
      if (success)
      {
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      }
      else
      {
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert);
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

open System

let callTryParse (stringToConvert: string) =
    match Byte.TryParse stringToConvert with
    | true, byteValue ->
        printfn $"Converted '{stringToConvert}' to {byteValue}"
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

let byteStrings = 
    [ null; String.Empty; "1024"
      "100.1"; "100"; "+100"; "-100"
      "000000000000000100"; "00,100"
      "   20   "; "FF"; "0x1F" ]

for byteString in byteStrings do
    callTryParse byteString

// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

Module ByteConversion
   Public Sub Main()
      Dim byteStrings() As String = { Nothing, String.Empty, "1024", 
                                    "100.1", "100", "+100", "-100",
                                    "000000000000000100", "00,100",
                                    "   20   ", "FF", "0x1F"}

      For Each byteString As String In byteStrings
        CallTryParse(byteString)
      Next
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String)  
      Dim byteValue As Byte
      Dim success As Boolean = Byte.TryParse(stringToConvert, byteValue)
      If success Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert)
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '' failed.
'       Attempted conversion of '' failed.
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Attempted conversion of '00,100' failed.
'       Converted '   20   ' to 20
'       Attempted conversion of 'FF' failed.
'       Attempted conversion of '0x1F' failed.

Poznámky

Převod se nezdaří a metoda vrátí false , pokud s parametr není ve správném formátu, pokud je null nebo String.Empty, nebo pokud představuje číslo menší než MinValue nebo větší než MaxValue.

Metoda Byte.TryParse(String, Byte) je podobná Byte.Parse(String) metodě , s tím rozdílem, že TryParse(String, Byte) nevyvolá výjimku, pokud se převod nezdaří.

Parametr s by měl být řetězcovým vyjádřením čísla v následujícím tvaru:

[ws][sign]digits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné místo.
sign	Volitelné kladné znaménko podle NumberFormatInfo.PositiveSign vlastnosti aktuální jazykové verze.
Číslic	Posloupnost desetinných číslic v rozsahu od 0 do 9.

Parametr se s interpretuje pomocí Integer stylu . Kromě desetinných číslic hodnoty bajtů jsou povoleny pouze počáteční a koncové mezery společně s počátečním znaménkem. (Pokud znaménko existuje, musí se jednat o kladné znaménko, jinak metoda vyvolá OverflowExceptionznak .) Pokud chcete explicitně definovat prvky stylu společně s informacemi o formátování specifické pro jazykovou verzi, které mohou být přítomny v s, použijte metodu Byte.Parse(String, NumberStyles, IFormatProvider) .

Parametr s se parsuje pomocí informací o formátování v objektu NumberFormatInfo pro aktuální jazykovou verzi. Další informace naleznete v tématu NumberFormatInfo.CurrentInfo.

Toto přetížení Byte.TryParse(String, Byte) metody interpretuje všechny číslice v parametru s jako desetinné číslice. Chcete-li parsovat řetězcovou reprezentaci šestnáctkového čísla, zavolejte Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) přetížení.

Viz také

Platí pro

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se parsovat rozsah znaků na hodnotu.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = ISpanParsable<System::Byte>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametry

s: ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro sjazykovou verzi.

result: Byte

Když tato metoda vrátí, obsahuje výsledek úspěšné analýzy snebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud s byl úspěšně parsován, jinak hodnota false.

Platí pro

TryParse(String, IFormatProvider, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se parsovat řetězec na hodnotu.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = IParsable<System::Byte>::TryParse;

public static bool TryParse (string? s, IFormatProvider? provider, out byte result);

static member TryParse : string * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametry

s: String

Řetězec, který se má analyzovat.

provider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro sjazykovou verzi.

result: Byte

Když tato metoda vrátí, obsahuje výsledek úspěšné analýzy s nebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud s byl úspěšně parsován, jinak hodnota false.

Platí pro

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

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se parsovat rozsah znaků UTF-8 na hodnotu.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametry

utf8Text: ReadOnlySpan<Byte>

Rozsah znaků UTF-8, které se mají analyzovat.

style: NumberStyles

Bitové kombinace stylů čísel, které se můžou vyskytovat v nástroji utf8Text.

provider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro utf8Textjazykovou verzi.

result: Byte

Při vrácení obsahuje výsledek úspěšné analýzy utf8Text nebo nedefinovanou hodnotu při selhání.

Návraty

Boolean

true pokud utf8Text byl úspěšně parsován, jinak hodnota false.

Platí pro

TryParse(ReadOnlySpan<Byte>, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se převést znakový rozsah UTF-8 obsahující řetězcové vyjádření čísla na jeho 8bitový celočíselný ekvivalent bez znaménka.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse (ReadOnlySpan<byte> utf8Text, out byte result);

static member TryParse : ReadOnlySpan<byte> * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Byte) As Boolean

Parametry

utf8Text: ReadOnlySpan<Byte>

Rozsah obsahující znaky UTF-8 představující číslo, které chcete převést.

result: Byte

Když tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu bez znaménka, která odpovídá číslu obsaženému v utf8Text případě úspěšného převodu, nebo nula, pokud se převod nezdařil. Tento parametr je předán neinicializován; jakákoli hodnota původně zadaná ve výsledku bude přepsána.

Návraty

Boolean

true pokud utf8Text byl úspěšně převeden, jinak hodnota false.

Platí pro

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

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

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

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result);

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out byte result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametry

s: ReadOnlySpan<Char>

Rozsah obsahující znaky představující číslo, které se má převést. Rozsah se interpretuje pomocí Integer stylu .

style: NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota, která se má zadat, je Integer.

provider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro sjazykovou verzi. Pokud provider je null, použije se aktuální jazyková verze vlákna.

result: Byte

Když tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu bez znaménka, která odpovídá číslu obsaženému v s případě úspěšného převodu, nebo nula, pokud se převod nezdařil. Převod selže, pokud s parametr je null nebo Empty, nemá správný formát nebo představuje číslo menší než Byte.MinValue nebo větší než Byte.MaxValue. Tento parametr je předán neinicializován; jakákoli hodnota původně zadaná v result bude přepsána.

Návraty

Boolean

true pokud s byl úspěšně převeden, jinak hodnota false.

Platí pro

TryParse(String, NumberStyles, IFormatProvider, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

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

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result);

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public static bool TryParse (string s, System.Globalization.NumberStyles style, IFormatProvider provider, out byte result);

public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametry

s: String

Řetězec obsahující číslo k převedení. Řetězec se interpretuje pomocí stylu určeného parametrem style.

style: NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota, která se má zadat, je Integer.

provider: IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro sjazykovou verzi. Pokud provider je null, použije se aktuální jazyková verze vlákna.

result: Byte

Návraty

Boolean

true pokud s byl úspěšně převeden, jinak hodnota false.

Výjimky

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier hodnot a HexNumber .

Příklady

Následující příklad volá metodu TryParse(String, NumberStyles, IFormatProvider, Byte) s několika různými řetězcovými hodnotami.

using namespace System;
using namespace System::Globalization;

void CallTryParse(String^ byteString, NumberStyles styles);

void main()
{
   String^ byteString; 
   NumberStyles styles;

   byteString = "1024";
   styles = NumberStyles::Integer;
   CallTryParse(byteString, styles);

   byteString = "100.1";
   styles = NumberStyles::Integer | NumberStyles::AllowDecimalPoint;
   CallTryParse(byteString, styles);

   byteString = "100.0";
   CallTryParse(byteString, styles);

   byteString = "+100";
   styles = NumberStyles::Integer | NumberStyles::AllowLeadingSign 
            | NumberStyles::AllowTrailingSign;
   CallTryParse(byteString, styles);

   byteString = "-100";
   CallTryParse(byteString, styles);

   byteString = "000000000000000100";
   CallTryParse(byteString, styles);

   byteString = "00,100";
   styles = NumberStyles::Integer | NumberStyles::AllowThousands;
   CallTryParse(byteString, styles);

   byteString = "2E+3   ";
   styles = NumberStyles::Integer | NumberStyles::AllowExponent;
   CallTryParse(byteString, styles);

   byteString = "FF";
   styles = NumberStyles::HexNumber;
   CallTryParse(byteString, styles);

   byteString = "0x1F";
   CallTryParse(byteString, styles);
}

void CallTryParse(String^ stringToConvert, NumberStyles styles)
{  
   Byte byteValue;
   bool result = Byte::TryParse(stringToConvert, styles, 
                                 (IFormatProvider^) nullptr , byteValue);
   if (result)
      Console::WriteLine("Converted '{0}' to {1}", 
                     stringToConvert, byteValue);
   else
      Console::WriteLine("Attempted conversion of '{0}' failed.", 
                        stringToConvert);
}
// The example displays the following output:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.}

using System;
using System.Globalization;

public class ByteConversion2
{
   public static void Main()
   {
      string byteString;
      NumberStyles styles;

      byteString = "1024";
      styles = NumberStyles.Integer;
      CallTryParse(byteString, styles);

      byteString = "100.1";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(byteString, styles);

      byteString = "100.0";
      CallTryParse(byteString, styles);

      byteString = "+100";
      styles = NumberStyles.Integer | NumberStyles.AllowLeadingSign
               | NumberStyles.AllowTrailingSign;
      CallTryParse(byteString, styles);

      byteString = "-100";
      CallTryParse(byteString, styles);

      byteString = "000000000000000100";
      CallTryParse(byteString, styles);

      byteString = "00,100";
      styles = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallTryParse(byteString, styles);

      byteString = "2E+3   ";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(byteString, styles);

      byteString = "FF";
      styles = NumberStyles.HexNumber;
      CallTryParse(byteString, styles);

      byteString = "0x1F";
      CallTryParse(byteString, styles);
   }

   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      Byte byteValue;
      bool result = Byte.TryParse(stringToConvert, styles,
                                  null as IFormatProvider, out byteValue);
      if (result)
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      else
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert.ToString());
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

open System
open System.Globalization

let callTryParse (stringToConvert: string) (styles: NumberStyles) =
    match Byte.TryParse(stringToConvert, styles, null) with
    | true, byteValue ->
        printfn $"Converted '{stringToConvert}' to {byteValue}"
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."
                        
[<EntryPoint>]
let main _ =
    let byteString = "1024"
    let styles = NumberStyles.Integer
    callTryParse byteString styles

    let byteString = "100.1"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse byteString styles

    let byteString = "100.0"
    callTryParse byteString styles

    let byteString = "+100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign
    callTryParse byteString styles

    let byteString = "-100"
    callTryParse byteString styles

    let byteString = "000000000000000100"
    callTryParse byteString styles

    let byteString = "00,100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callTryParse byteString styles

    let byteString = "2E+3   "
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse byteString styles

    let byteString = "FF"
    let styles = NumberStyles.HexNumber
    callTryParse byteString styles

    let byteString = "0x1F"
    callTryParse byteString styles

    0

// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

Imports System.Globalization

Module ByteConversion2
   Public Sub Main()
      Dim byteString As String 
      Dim styles As NumberStyles
      
      byteString = "1024"
      styles = NumberStyles.Integer
      CallTryParse(byteString, styles)
      
      byteString = "100.1"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(byteString, styles)
      
      byteString = "100.0"
      CallTryParse(byteString, styles)
      
      byteString = "+100"
      styles = NumberStyles.Integer Or NumberStyles.AllowLeadingSign _
               Or NumberStyles.AllowTrailingSign
      CallTryParse(byteString, styles)
      
      byteString = "-100"
      CallTryParse(byteString, styles)
      
      byteString = "000000000000000100"
      CallTryParse(byteString, styles)
      
      byteString = "00,100"      
      styles = NumberStyles.Integer Or NumberStyles.AllowThousands
      CallTryParse(byteString, styles)
      
      byteString = "2E+3   "
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(byteString, styles)
      
      byteString = "FF"
      styles = NumberStyles.HexNumber
      CallTryParse(byteString, styles)
      
      byteString = "0x1F"
      CallTryParse(byteString, styles)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles As NumberStyles)  
      Dim byteValue As Byte
      Dim result As Boolean = Byte.TryParse(stringToConvert, styles, Nothing, _
                                            byteValue)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         If stringToConvert Is Nothing Then stringToConvert = ""
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert.ToString())
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100.0' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Converted '00,100' to 100
'       Attempted conversion of '2E+3   ' failed.
'       Converted 'FF' to 255
'       Attempted conversion of '0x1F' failed.

Poznámky

Metoda TryParse se podobá Parse metodě s tím rozdílem, že v případě selhání převodu TryParse nevyvolá výjimku.

Parametr se s parsuje pomocí informací o formátování v objektu NumberFormatInfo zadaném parametrem provider .

Parametr style definuje prvky stylu (například prázdné znaky nebo kladné znaménko), které jsou povoleny v parametru s pro úspěšnou operaci analýzy. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . V závislosti na hodnotě styles může parametr obsahovat následující prvky:

[ws] [$] [sign]digits[.fractional_digits][e[sign]digits][ws]

Nebo pokud style parametr obsahuje AllowHexSpecifier:

[ws]hexdigits[ws]

Prvky v hranatých závorkách ( [ a ] ) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné místo. Prázdné znaky se mohou objevit na začátku, `s` pokud `style` obsahuje NumberStyles.AllowLeadingWhite příznak, nebo na konci, pokud styl obsahuje NumberStyles.AllowTrailingWhite příznak.
$	Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyPositivePattern vlastností objektu NumberFormatInfo vrácenou GetFormat metodou parametru `provider` . Symbol měny se může zobrazit v `s` , pokud `style` obsahuje NumberStyles.AllowCurrencySymbol příznak .
sign	Volitelné kladné znaménko. (Pokud je v `s`souboru obsaženo záporné znaménko, operace parsování selže. Znaménko se může zobrazit na začátku, `s` pokud `style` obsahuje NumberStyles.AllowLeadingSign příznak, nebo na konci `s` , pokud `style` obsahuje NumberStyles.AllowTrailingSign příznak.
Číslic	Řada číslic od 0 do 9.
.	Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky jazykové verze určené nástrojem `provider` se může zobrazit v `s` , pokud `style` obsahuje NumberStyles.AllowDecimalPoint příznak .
Fractional_digits	Jeden nebo více výskytů číslice 0. Desetinné číslice se můžou zobrazit jen v `s` případě, že `style`NumberStyles.AllowDecimalPoint obsahuje příznak .
E	Znak e nebo E, který označuje, že hodnota je reprezentována v exponenciálním zápisu. Parametr `s` může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud `style` obsahuje příznak .
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.

Poznámka

Operace analýzy ignoruje všechny ukončující znaky s NUL (U+0000) bez ohledu na hodnotu argumentu style .

Řetězec pouze s desítkovými číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů řídí prvky, které mohou být, ale nejsou nutné, aby byly přítomny v tomto vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v snástroji .

Nesložené hodnoty NumberStyles	Prvky, které jsou povoleny v s, kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Elementy . a fractional_digits. Fractional_digits však musí obsahovat pouze jednu nebo více číslic 0, nebo vrátí metoda hodnotu `false`.
NumberStyles.AllowExponent	Parametr `s` může také používat exponenciální zápis. Pokud `s` představuje číslo v exponenciálním zápisu, musí představovat celé číslo v rozsahu Byte datového typu bez nenulové zlomkové komponenty.
NumberStyles.AllowLeadingWhite	Element ws na začátku .`s`
NumberStyles.AllowTrailingWhite	Element ws na konci .`s`
NumberStyles.AllowLeadingSign	Před číslicemi se může zobrazit kladné znaménko.
NumberStyles.AllowTrailingSign	Za číslicemi se může zobrazit kladné znaménko.
NumberStyles.AllowParentheses	I když je tento příznak podporovaný, vrátí metoda hodnotu `false` , pokud jsou v `s`objektu k dispozici závorky.
NumberStyles.AllowThousands	I když se symbol oddělovače skupin může zobrazit v `s`, může mu předcházet pouze jedna nebo více číslic 0.
NumberStyles.AllowCurrencySymbol	Element .$

NumberStyles.AllowHexSpecifier Pokud se použije příznak, s musí to být šestnáctková hodnota bez předpony. Například F3 úspěšně analyzuje, ale "0xF3" ne. Jedinými dalšími příznaky, které se můžou v style nástroji vyskytovat, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl čísla , NumberStyles.HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Parametr provider je IFormatProvider implementace, například CultureInfo objekt nebo NumberFormatInfo objekt, jehož GetFormat metoda vrací NumberFormatInfo objekt. Objekt NumberFormatInfo poskytuje informace specifické pro jazykovou verzi formátu .s

Viz také

Platí pro

Sdílet prostřednictvím

Byte.TryParse Metoda

Definice

Přetížení

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Parametry

Návraty

Platí pro

TryParse(ReadOnlySpan<Char>, Byte)

Parametry

Návraty

Platí pro

TryParse(String, Byte)

Parametry

Návraty

Příklady

Poznámky

Viz také

Platí pro

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Parametry

Návraty

Platí pro

TryParse(String, IFormatProvider, Byte)

Parametry

Návraty

Platí pro

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

Parametry

Návraty

Platí pro

TryParse(ReadOnlySpan<Byte>, Byte)

Parametry

Návraty

Platí pro

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

Parametry

Návraty

Platí pro

TryParse(String, NumberStyles, IFormatProvider, Byte)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Váš názor

Další materiály