Byte.TryParse Metoda

Definice

Obor názvů:: System

Sestavení:: netstandard.dll, System.Runtime.dll

Sestavení:: System.Runtime.dll

Sestavení:: netstandard.dll

Sestavení:: mscorlib.dll, System.Runtime.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ězcovou reprezentaci čísla na Byte jeho ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

Přetížení

Name	Description
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Char>, Byte)	Pokusí se převést reprezentaci čísla na jeho Byte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(String, Byte)	Pokusí se převést řetězcovou reprezentaci čísla na Byte jeho ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Pokusí se analyzovat rozsah znaků do hodnoty.
TryParse(String, IFormatProvider, Byte)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Byte>, Byte)	Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na jeho 8bitové celé číslo bez znaménka ekvivalent.
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, jestli byl převod úspěšný nebo neúspěšný.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho Byte ekvivalent. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.

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 pro analýzu.

provider: IFormatProvider

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

result: Byte

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

Návraty

Boolean

true pokud utf8Text byl úspěšně analyzován; jinak , false.

Platí pro

TryParse(ReadOnlySpan<Char>, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se převést reprezentaci čísla na jeho Byte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl ú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

Pokud tato metoda vrátí, obsahuje Byte hodnotu odpovídající číslu obsaženému v s případě úspěchu převodu nebo nula, pokud převod selhal. Tento parametr je předán neinicializovaný; jakákoli hodnota, která byla původně zadána, result bude přepsána.

Návraty

Boolean

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

Platí pro

TryParse(String, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se převést řetězcovou reprezentaci čísla na Byte jeho 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, které se má převést.

result: Byte

Návraty

Boolean

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

Příklady

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

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 selže a metoda vrátí, pokud s parametr není ve správném formátu, pokud je null nebo String.Empty, nebo pokud představuje číslo menší nebo MinValue větší než MaxValue.false

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

Parametr s by měl být řetězcovou reprezentací čísla v následující podobě:

[ws][sign]digits[ws]

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

prvek	Description
Ws	Volitelné mezery.
znaménko	Volitelné kladné znaménko, jak je určeno NumberFormatInfo.PositiveSign vlastností aktuální jazykové verze.
Číslic	Posloupnost desetinných číslic v rozsahu od 0 do 9.

Parametr s se interpretuje pomocí Integer stylu. Kromě desetinných číslic bajtové hodnoty jsou povoleny pouze počáteční a koncové mezery spolu s počátečním znakem. (Pokud je znaménko přítomno, musí to být kladné znaménko nebo metoda vyvolá OverflowException.) Chcete-li explicitně definovat prvky stylu spolu 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 je analyzován pomocí informací o formátování v objektu NumberFormatInfo pro aktuální jazykovou verzi. Další informace najdete na webu NumberFormatInfo.CurrentInfo.

Toto přetížení Byte.TryParse(String, Byte) metody interpretuje všechny číslice v parametru s jako desítkové čí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

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se analyzovat rozsah znaků do hodnoty.

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 sformátování specifické pro jazykovou verzi .

result: Byte

Pokud 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ě analyzován; jinak , false.

Platí pro

TryParse(String, IFormatProvider, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se analyzovat řetězec do hodnoty.

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 sformátování specifické pro jazykovou verzi .

result: Byte

Pokud 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ě analyzován; jinak , false.

Platí pro

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

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.

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 pro analýzu.

style: NumberStyles

Bitová kombinace stylů čísel, které mohou být přítomny v utf8Text.

provider: IFormatProvider

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

result: Byte

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

Návraty

Boolean

true pokud utf8Text byl úspěšně analyzován; jinak , false.

Platí pro

TryParse(ReadOnlySpan<Byte>, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na jeho 8bitové celé číslo bez znaménka ekvivalent.

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é se má převést.

result: Byte

Pokud tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu bez znaménka odpovídající číslu obsaženému v utf8Text případě úspěchu převodu nebo nula v případě selhání převodu. Tento parametr je předán neinicializovaný; jakákoli hodnota původně zadaná ve výsledku se přepíše.

Návraty

Boolean

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

Platí pro

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

Zdroj:: Byte.cs

Zdroj:: Byte.cs

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, jestli byl převod úspěšný nebo neúspěšný.

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, [Runtime::InteropServices::Out] System::Byte % result);

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, kterou je třeba zadat, je Integer.

provider: IFormatProvider

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

result: Byte

Pokud tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu bez znaménka odpovídající číslu obsaženému v s případě úspěchu převodu nebo nula v případě selhání převodu. Převod selže, pokud s je null parametr nebo Empty, není ve správném formátu nebo představuje číslo menší než Byte.MinValue nebo větší než Byte.MaxValue. Tento parametr je předán neinicializovaný; jakákoli hodnota, která byla původně zadána, result bude přepsána.

Návraty

Boolean

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

Platí pro

TryParse(String, NumberStyles, IFormatProvider, Byte)

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

Zdroj:: Byte.cs

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

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, které chcete převést. Řetězec se interpretuje pomocí stylu určeného znakem style.

style: NumberStyles

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

provider: IFormatProvider

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

result: Byte

Návraty

Boolean

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

Výjimky

ArgumentException

style není NumberStyles hodnota.

nebo

style není kombinací AllowHexSpecifier a HexNumber hodnot.

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 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 je podobná Parse metodě, s výjimkou TryParse metody nevyvolá výjimku, pokud převod selže.

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

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

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

Nebo pokud parametr style zahrnuje AllowHexSpecifier:

[ws]hexdigits[ws]

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

prvek	Description
Ws	Volitelné mezery. Prázdné znaky se můžou objevit na začátku `s` , pokud `style` příznak obsahuje NumberStyles.AllowLeadingWhite , nebo na konci s, pokud styl obsahuje NumberStyles.AllowTrailingWhite příznak.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyPositivePattern vlastností NumberFormatInfo objektu vráceného GetFormat metodou parametru `provider` . Symbol měny se může zobrazit, `s` pokud `style` obsahuje NumberStyles.AllowCurrencySymbol příznak.
znaménko	Volitelné kladné znaménko. (Operace analýzy selže, pokud se v `s`souboru nachází záporné znaménko.) Znaménko se může zobrazit na začátku `s` , pokud `style` obsahuje NumberStyles.AllowLeadingSign příznak, nebo na konci `s` , pokud `style` příznak NumberStyles.AllowTrailingSign obsahuje.
Číslic	Posloupnost číslic od 0 do 9.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky zadané jazykovou `provider` verzí se může zobrazit v `s` případě, že `style` obsahuje NumberStyles.AllowDecimalPoint příznak.
Fractional_digits	Jeden nebo více výskytů číslice 0. Desetinná číslice se můžou zobrazovat `s` jenom v případě, že `style` příznak obsahuje NumberStyles.AllowDecimalPoint .
e	Znak e nebo E, který označuje, že hodnota je reprezentována exponenciálním zápisem. Parametr `s` může představovat číslo v exponenciálním zápisu`style`, pokud NumberStyles.AllowExponent obsahuje příznak.
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka:

Všechny ukončující nulové znaky (U+0000) jsou s ignorovány operací analýzy bez ohledu na hodnotu argumentu style .

Řetězec s desetinnými číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů ovládacích prvků, které mohou být, ale nemusí být 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 s.

Neseparované hodnoty NumberStyles	Prvky povolené v s kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Prvky . a fractional_digits . Nicméně , fractional_digits se musí skládat pouze z jedné nebo více 0 číslic nebo metoda vrátí `false`.
NumberStyles.AllowExponent	Parametr `s` může také použít 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é desetinné komponenty.
NumberStyles.AllowLeadingWhite	Element ws na začátku `s`.
NumberStyles.AllowTrailingWhite	Prvek ws na konci .`s`
NumberStyles.AllowLeadingSign	Kladné znaménko se může zobrazit před číslicemi.
NumberStyles.AllowTrailingSign	Po číslicích se může zobrazit kladné znaménko.
NumberStyles.AllowParentheses	I když je tento příznak podporován, metoda vrátí `false` , pokud jsou v závorkách přítomny `s`.
NumberStyles.AllowThousands	I když se symbol oddělovače skupin může objevit, `s`může mu předcházet pouze jedna nebo více 0 číslic.
NumberStyles.AllowCurrencySymbol	Prvek $ .

NumberStyles.AllowHexSpecifier Pokud se příznak použije, s musí být šestnáctková hodnota bez předpony. Například "F3" se úspěšně parsuje, ale "0xF3" ne. Jediné ostatní příznaky, které mohou být přítomny jsou styleNumberStyles.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

Váš názor

Byla tato stránka užitečná?

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