SByte.TryParse Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Převede řetězcové vyjádření čísla na jeho 8bitové celé číslo se znaky. Návratový kód označuje, jestli byl převod úspěšný nebo neúspěšný.

Přetížení

TryParse(ReadOnlySpan<Byte>, IFormatProvider, SByte)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Char>, SByte)	Pokusí se převést reprezentaci rozsahu čísla na jeho SByte ekvivalentu a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(String, SByte)	Pokusí se převést řetězcové vyjádření čísla na jeho SByte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, IFormatProvider, SByte)	Pokusí se analyzovat rozsah znaků do hodnoty.
TryParse(String, IFormatProvider, SByte)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, SByte)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Byte>, SByte)	Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na jeho 8bitové celé číslo se znaménkem.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, SByte)	Pokusí se převést reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho SByte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.
TryParse(String, NumberStyles, IFormatProvider, SByte)	Pokusí se převést řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho SByte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, SByte)

Zdroj:

SByte.cs

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

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

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

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

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

Parametry

utf8Text

ReadOnlySpan<Byte>

Rozsah znaků UTF-8 pro analýzu.

provider

IFormatProvider

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

result

SByte

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

Návraty

Boolean

true, pokud se utf8Text úspěšně parsoval; jinak false.

TryParse(ReadOnlySpan<Char>, SByte)

Zdroj:

SByte.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Pokusí se převést reprezentaci rozsahu čísla na jeho SByte ekvivalentu 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::SByte % result);

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

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

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

Parametry

s

ReadOnlySpan<Char>

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

result

SByte

Pokud tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu, která je ekvivalentní číslu obsaženému v s, pokud převod proběhl úspěšně, nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty, není ve správném formátu nebo představuje číslo, které je menší než SByte.MinValue nebo větší než SByte.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

Boolean

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

TryParse(String, SByte)

Zdroj:

SByte.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Pokusí se převést řetězcové vyjádření čísla na jeho SByte 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::SByte % result);

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

static member TryParse : string * sbyte -> bool

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

Parametry

s

String

Řetězec obsahující číslo, které se má převést.

result

SByte

Pokud tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu, která je ekvivalentní číslu obsaženému v s, pokud převod proběhl úspěšně, nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty, není ve správném formátu nebo představuje číslo, které je menší než SByte.MinValue nebo větší než SByte.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

Boolean

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

Příklady

Následující příklad se pokusí převést řetězce v poli na SByte hodnoty voláním TryParse(String, SByte) metoda.

string[] numericStrings = {"-3.6", "12.8", "+16.7", "    3   ", "(17)", 
                           "-17", "+12", "18-", "987", "1,024", "  127 "};
sbyte number;
foreach (string numericString in numericStrings)
{
   if (sbyte.TryParse(numericString, out number)) 
      Console.WriteLine("Converted '{0}' to {1}.", numericString, number);
   else
      Console.WriteLine("Cannot convert '{0}' to an SByte.", numericString);
}
// The example displays the following output to the console:
//       Cannot convert '-3.6' to an SByte.
//       Cannot convert '12.8' to an SByte.
//       Cannot convert '+16.7' to an SByte.
//       Converted '    3   ' to 3.
//       Cannot convert '(17)' to an SByte.
//       Converted '-17' to -17.
//       Converted '+12' to 12.
//       Cannot convert '18-' to an SByte.
//       Cannot convert '987' to an SByte.
//       Cannot convert '1,024' to an SByte.
//       Converted '  127 ' to 127.

open System

let numericStrings = 
    [| "-3.6"; "12.8"; "+16.7"; "    3   "; "(17)" 
       "-17"; "+12"; "18-"; "987"; "1,024"; "  127 " |]

for numericString in numericStrings do
    match SByte.TryParse numericString with 
    | true, number ->
        printfn $"Converted '{numericString}' to {number}."
    | _ ->
        printfn $"Cannot convert '{numericString}' to an SByte."
// The example displays the following output to the console:
//       Cannot convert '-3.6' to an SByte.
//       Cannot convert '12.8' to an SByte.
//       Cannot convert '+16.7' to an SByte.
//       Converted '    3   ' to 3.
//       Cannot convert '(17)' to an SByte.
//       Converted '-17' to -17.
//       Converted '+12' to 12.
//       Cannot convert '18-' to an SByte.
//       Cannot convert '987' to an SByte.
//       Cannot convert '1,024' to an SByte.
//       Converted '  127 ' to 127.

Dim numericStrings() As String = {"-3.6", "12.8", "+16.7", "    3   ", _
                                  "(17)", "-17", "+12", "18-", "987", _
                                  "1,024", "  127 "}
Dim number As SByte
For Each numericString As String In numericStrings
   If SByte.TryParse(numericString, number) Then
      Console.WriteLine("Converted '{0}' to {1}.", numericString, number)
   Else
      Console.WriteLine("Cannot convert '{0}' to an SByte.", numericString)
   End If      
Next
' The example displays the following output to the console:
'       Cannot convert '-3.6' to an SByte.
'       Cannot convert '12.8' to an SByte.
'       Cannot convert '+16.7' to an SByte.
'       Converted '    3   ' to 3.
'       Cannot convert '(17)' to an SByte.
'       Converted '-17' to -17.
'       Converted '+12' to 12.
'       Cannot convert '18-' to an SByte.
'       Cannot convert '987' to an SByte.
'       Cannot convert '1,024' to an SByte.
'       Converted '  127 ' to 127.

Poznámky

Metoda SByte.TryParse(String, SByte) se podobá metodě SByte.Parse(String) s tím rozdílem, že při selhání převodu nevyvolá výjimku. Tato metoda eliminuje potřebu použití zpracování výjimek k otestování FormatException, pokud je value neplatná a nelze ji úspěšně analyzovat.

Parametr s by měl být řetězcovou reprezentací desetinného čísla v následujícím formátu:

[ws] [znaménko]číslice[ws]

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

Element	Popis
ws	Volitelné prázdné znaky.
znaménko	Volitelné znaménko. Platné znaky znaménka jsou určeny NumberFormatInfo.NegativeSign a NumberFormatInfo.PositiveSign vlastnostmi aktuální jazykové verze.
číslice	Posloupnost desetinných číslic v rozsahu od 0 do 9.

Poznámka

Řetězec zadaný parametrem value nesmí obsahovat oddělovače skupin ani oddělovač desetinných míst a nesmí obsahovat desetinnou část.

Parametr s se interpretuje pomocí stylu NumberStyles.Integer. Kromě desetinných číslic jsou povoleny pouze úvodní a koncové mezery s počátečním symbolem. Chcete-li explicitně definovat prvky stylu s informacemi o formátování specifické pro jazykovou verzi, které mohou být přítomny v value, zavolejte metodu TryParse(String, NumberStyles, IFormatProvider, SByte).

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

Toto přetížení interpretuje všechny číslice v parametru value jako desítkové číslice. Chcete-li parsovat řetězcovou reprezentaci šestnáctkového čísla, zavolejte místo toho TryParse(String, NumberStyles, IFormatProvider, SByte) přetížení.

Viz také

• Ukázka : rozhraní .NET Core WinForms (C#)
• ukázka : .NET Core WinForms Formatting Utility (Visual Basic)

TryParse(ReadOnlySpan<Char>, IFormatProvider, SByte)

Zdroj:

SByte.cs

Pokusí se analyzovat rozsah znaků do hodnoty.

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

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

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

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

Parametry

s

ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider

IFormatProvider

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

result

SByte

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 se s úspěšně parsoval; jinak false.

TryParse(String, IFormatProvider, SByte)

Zdroj:

SByte.cs

Pokusí se analyzovat řetězec do hodnoty.

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

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

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

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

Parametry

s

String

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

provider

IFormatProvider

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

result

SByte

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 se s úspěšně parsoval; jinak false.

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

Zdroj:

SByte.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::SByte % result) = System::Numerics::INumberBase<System::SByte>::TryParse;

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

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

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As SByte) 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 formátování specifické pro jazykovou verzi o utf8Text.

result

SByte

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

Návraty

Boolean

true, pokud se utf8Text úspěšně parsoval; jinak false.

TryParse(ReadOnlySpan<Byte>, SByte)

Zdroj:

SByte.cs

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

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

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

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

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

Parametry

utf8Text

ReadOnlySpan<Byte>

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

result

SByte

Pokud tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu odpovídající číslu obsaženému v utf8Text, pokud převod proběhl úspěšně, 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 byl utf8Text úspěšně převeden; jinak false.

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

Zdroj:

SByte.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Pokusí se převést reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho SByte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

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

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

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

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

Parametry

s

ReadOnlySpan<Char>

Rozsah obsahující znaky, které představují číslo k převodu.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát s. Typická hodnota pro zadání je Integer.

provider

IFormatProvider

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

result

SByte

Pokud tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu odpovídající číslu obsaženému v s, pokud převod proběhl úspěšně nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty, není ve formátu kompatibilním s stylenebo představuje číslo menší než SByte.MinValue nebo větší než SByte.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

Boolean

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

TryParse(String, NumberStyles, IFormatProvider, SByte)

Zdroj:

SByte.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int16.TryParse(String, Int16)

Pokusí se převést řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho SByte ekvivalent a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

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

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

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

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

Parametry

s

String

Řetězec představující číslo, které se má převést.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje povolený formát s. Typická hodnota pro zadání je Integer.

provider

IFormatProvider

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

result

SByte

Pokud tato metoda vrátí, obsahuje 8bitovou celočíselnou hodnotu odpovídající číslu obsaženému v s, pokud převod proběhl úspěšně nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty, není ve formátu kompatibilním s stylenebo představuje číslo menší než SByte.MinValue nebo větší než SByte.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

Boolean

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

Výjimky

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier a HexNumber.

Příklady

Následující příklad volá metodu TryParse(String, NumberStyles, IFormatProvider, SByte) s řadou různých řetězců a NumberStyles hodnot.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string numericString;
      NumberStyles styles;
      
      numericString = "106";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);
      
      numericString = "-106";
      styles = NumberStyles.None;
      CallTryParse(numericString, styles);
      
      numericString = "103.00";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);
      
      numericString = "103.72";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10E-01";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(numericString, styles); 
      
      numericString = "12E-01";
      CallTryParse(numericString, styles);
          
      numericString = "12E01";
      CallTryParse(numericString, styles); 
      
      numericString = "C8";
      CallTryParse(numericString, NumberStyles.HexNumber);
      
      numericString = "0x8C";
      CallTryParse(numericString, NumberStyles.HexNumber);
   }
   
   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      sbyte number;
      bool result = SByte.TryParse(stringToConvert, styles, 
                                   CultureInfo.InvariantCulture, out number);
      if (result)
         Console.WriteLine($"Converted '{stringToConvert}' to {number}.");
      else
         Console.WriteLine($"Attempted conversion of '{stringToConvert}' failed.");
   }
}
// The example displays the following output:
//       Converted '106' to 106.
//       Attempted conversion of '-106' failed.
//       Converted '103.00' to 103.
//       Attempted conversion of '103.72' failed.
//       Converted '10E-01' to 1.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E01' to 120.
//       Converted 'C8' to -56.
//       Attempted conversion of '0x8C' failed.

open System
open System.Globalization

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

[<EntryPoint>]
let main _ =
    let numericString = "106"
    let styles = NumberStyles.Integer
    callTryParse numericString styles
    
    let numericString = "-106"
    let styles = NumberStyles.None
    callTryParse numericString styles
    
    let numericString = "103.00"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles
    
    let numericString = "103.72"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "10E-01"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse numericString styles 
    
    let numericString = "12E-01"
    callTryParse numericString styles
        
    let numericString = "12E01"
    callTryParse numericString styles 
    
    let numericString = "C8"
    callTryParse numericString NumberStyles.HexNumber
    
    let numericString = "0x8C"
    callTryParse numericString NumberStyles.HexNumber
    0

// The example displays the following output:
//       Converted '106' to 106.
//       Attempted conversion of '-106' failed.
//       Converted '103.00' to 103.
//       Attempted conversion of '103.72' failed.
//       Converted '10E-01' to 1.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E01' to 120.
//       Converted 'C8' to -56.
//       Attempted conversion of '0x8C' failed.

Imports System.Globalization

Module StringParsing
   Public Sub Main()
      Dim numericString As String
      Dim styles As NumberStyles
      
      numericString = "106"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      numericString = "-106"
      styles = NumberStyles.None
      CallTryParse(numericString, styles)
      
      numericString = "103.00"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)
      
      numericString = "103.72"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)

      numericString = "10E-01"
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(numericString, styles) 
      
      numericString = "12E-01"
      CallTryParse(numericString, styles)
          
      numericString = "12E01"
      CallTryParse(numericString, styles) 
      
      numericString = "C8"
      CallTryParse(numericString, NumberStyles.HexNumber)
      
      numericString = "0x8C"
      CallTryParse(numericString, NumberStyles.HexNumber)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles AS NumberStyles)
      Dim number As SByte
      Dim result As Boolean = SByte.TryParse(stringToConvert, styles, _
                                             CultureInfo.InvariantCulture, number)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           Convert.ToString(stringToConvert))
      End If                                                                           
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '106' to 106.
'       Attempted conversion of '-106' failed.
'       Converted '103.00' to 103.
'       Attempted conversion of '103.72' failed.
'       Converted '10E-01' to 1.
'       Attempted conversion of '12E-01' failed.
'       Converted '12E01' to 120.
'       Converted 'C8' to -56.
'       Attempted conversion of '0x8C' failed.

Poznámky

Metoda TryParse(String, NumberStyles, IFormatProvider, SByte) se podobá metodě Parse(String, NumberStyles, IFormatProvider) s tím rozdílem, že při selhání převodu nevyvolá výjimku. Tato metoda eliminuje potřebu použití zpracování výjimek k otestování FormatException, pokud je value neplatná a nelze ji úspěšně analyzovat.

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

[ws] [$] [znaménko] [číslice,]číslic[.fractional_digits][E[znaménko]exponential_digits][ws]

Pokud parametr style obsahuje AllowHexSpecifier, může parametr value obsahovat následující prvky:

[ws]šestnáctkové[ws]

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

Element	Popis
ws	Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku value, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite nebo na konci value, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována CurrencyPositivePattern vlastnost objektu NumberFormatInfo vrácenou GetFormat metodou parametru provider. Symbol měny se může zobrazit v value, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku value, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit na konci value pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v value k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice	Posloupnost číslic od 0 do 9.
,	Oddělovač skupin specifických pro jazykovou verzi. Oddělovač skupiny jazykové verze určené provider se může zobrazit v value, pokud style obsahuje příznak NumberStyles.AllowThousands.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky jazykové verze určené provider se může objevit v value, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint.
fractional_digits	Jeden nebo více výskytů číslice 0. Desetinná číslice se můžou v value zobrazovat jenom v případě, že style obsahuje příznak NumberStyles.AllowDecimalPoint.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr value může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
exponential_digits	Posloupnost číslic od 0 do 9. Parametr value může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

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

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

Neseloženého NumberStyles hodnot	Prvky povolené v hodnotě kromě číslic
None	Pouze desítkové číslice.
AllowDecimalPoint	Desetinná čárka (.) a prvky fractional_digits. fractional_digits však musí obsahovat pouze jednu nebo více číslic, nebo metoda vrátí false.
AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits. Pokud value představuje číslo v exponenciálním zápisu, nemůže mít nenulovou desetinnou komponentu.
AllowLeadingWhite	Element ws na začátku value.
AllowTrailingWhite	Prvek ws na konci value.
AllowLeadingSign	Prvek podepisující před číslice.
AllowTrailingSign	Znak prvek za číslice.
AllowParentheses	Znak prvek ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Oddělovač skupin (,) – element.
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. value však nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo konci value, znaménko na začátku valuea symbol desetinné čárky (.). Parametr value může také použít exponenciální zápis.
Number	Prvky ws, znaménko, oddělovač skupin (,) a desetinná čárka (.).
Any	Všechny prvky. value však nemůže představovat šestnáctkové číslo.

Pokud se používá příznak NumberStyles.AllowHexSpecifier, value musí být šestnáctková hodnota. Platné šestnáctkové číslice jsou 0-9, a-f a A-F. Jedinými dalšími příznaky, které mohou být přítomné v style, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl, HexNumber, který obsahuje oba příznaky prázdných znaků.)

Poznámka

Pokud value je řetězcová reprezentace šestnáctkového čísla, nemůže před ní předcházet žádná dekorace (například 0x nebo &h), která ho odlišuje jako šestnáctkové číslo. To způsobí selhání převodu.

Parametr provider je IFormatProvider implementace. Jeho GetFormat metoda vrátí objekt NumberFormatInfo, který poskytuje informace specifické pro jazykovou verzi o formátu value. Parametr provider může být některý z následujících:

• Objekt CultureInfo, který představuje jazykovou verzi, která poskytuje informace o formátování. Jeho GetFormat metoda vrátí objekt NumberFormatInfo, který poskytuje číselné informace o formátování pro danou jazykovou verzi.

• Objekt NumberFormatInfo, který poskytuje informace o číselném formátování. (Její implementace GetFormat se vrátí sama.)

• Vlastní objekt, který implementuje IFormatProvider. Jeho GetFormat metoda vytvoří instanci a vrátí objekt NumberFormatInfo, který poskytuje informace o formátování.

Pokud je providernull, použije se objekt NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

• Parse(String, NumberStyles, IFormatProvider)
• analýza číselných řetězců v rozhraní .NET