Double.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í.

Převede řetězcovou reprezentaci čísla na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný.

Přetížení

TryParse(String, IFormatProvider, Double)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(ReadOnlySpan<Char>, Double)	Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný.
TryParse(String, Double)	Převede řetězcovou reprezentaci čísla na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	Pokusí se analyzovat rozsah znaků do hodnoty.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Byte>, Double)	Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na ekvivalent čísla s dvojitou přesností s plovoucí desetinnou čárkou.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Převede rozsah znaků obsahující řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný.
TryParse(String, NumberStyles, IFormatProvider, Double)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný.

Poznámky

V .NET Core 3.0 a novějších se hodnoty, které jsou příliš velké na reprezentaci, zaokrouhlují na PositiveInfinity nebo NegativeInfinity podle požadavků specifikace IEEE 754. V předchozích verzích, včetně rozhraní .NET Framework, parsování hodnoty, která byla příliš velká, aby představovala selhání.

TryParse(String, IFormatProvider, Double)

Zdroj:: Double.cs

Zdroj:: Double.cs

Zdroj:: Double.cs

Pokusí se analyzovat řetězec do hodnoty.

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

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

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

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Double) 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: Double

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.

Platí pro

TryParse(ReadOnlySpan<Char>, Double)

Zdroj:: Double.cs

Zdroj:: Double.cs

Zdroj:: Double.cs

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

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

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

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

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

Parametry

s: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje řetězcovou reprezentaci čísla, která se má převést.

result: Double

Pokud tato metoda vrátí, obsahuje číslo s plovoucí desetinnou čárkou s dvojitou přesností odpovídající číselné hodnotě nebo symbolu obsaženému v parametru s, pokud převod proběhl úspěšně, nebo nulu, pokud převod selhal. Převod selže, pokud je parametr snull nebo prázdný. Pokud s je platné číslo menší než Double.MinValue, result je NegativeInfinity. Pokud s je platné číslo větší než Double.MaxValue, result je PositiveInfinity. 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.

Poznámky

Platí pro

TryParse(String, Double)

Zdroj:: Double.cs

Zdroj:: Double.cs

Zdroj:: Double.cs

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

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

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

static member TryParse : string * double -> bool

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

Parametry

s: String

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

result: Double

Pokud tato metoda vrátí, obsahuje číslo s plovoucí desetinnou čárkou s dvojitou přesností ekvivalent s parametru, pokud převod proběhl úspěšně nebo nula, pokud převod selhal. Převod selže, pokud je parametr snull nebo Empty nebo není číslo v platném formátu. Selže také v rozhraní .NET Framework a .NET Core 2.2 a starších verzích, pokud s představuje číslo menší než Double.MinValue nebo větší než Double.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 používá metodu TryParse(String, Double) k převodu řetězcových reprezentací číselných hodnot na Double hodnoty. Předpokládá se, že en-US je aktuální jazyková verze.

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "1,643.57", "$1,643.57", "-1.643e6",
                          "-168934617882109132", "123AE6",
                          null, String.Empty, "ABCDEF" };
      double number;

      foreach (var value in values) {
         if (Double.TryParse(value, out number))
            Console.WriteLine("'{0}' --> {1}", value, number);
         else
            Console.WriteLine("Unable to parse '{0}'.", value);
      }
   }
}
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.

open System

let values =
    [| "1,643.57"; "$1,643.57"; "-1.643e6"
       "-168934617882109132"; "123AE6"
       null; String.Empty; "ABCDEF" |]

for value in values do
    match Double.TryParse value with
    | true, number ->
        printfn $"'{value}' --> {number}"
    | _ ->
        printfn $"Unable to parse '{value}'."
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.

Module Example
   Public Sub Main()
      Dim values() As String = { "1,643.57", "$1,643.57", "-1.643e6", 
                                "-168934617882109132", "123AE6", 
                                Nothing, String.Empty, "ABCDEF" }
      Dim number As Double
      
      For Each value In values
         If Double.TryParse(value, number) Then
            Console.WriteLine("'{0}' --> {1}", value, number)
         Else
            Console.WriteLine("Unable to parse '{0}'.", value)      
         End If   
      Next   
   End Sub
End Module
' The example displays the following output:
'       '1,643.57' --> 1643.57
'       Unable to parse '$1,643.57'.
'       '-1.643e6' --> -1643000
'       '-168934617882109132' --> -1.68934617882109E+17
'       Unable to parse '123AE6'.
'       Unable to parse ''.
'       Unable to parse ''.
'       Unable to parse 'ABCDEF'.

Poznámky

Toto přetížení se liší od metody Double.Parse(String) vrácením logické hodnoty, která označuje, zda byla operace analýzy úspěšná místo vrácení analyzované číselné hodnoty. Eliminuje potřebu použití zpracování výjimek k otestování FormatException v případě, že s je neplatný a nelze jej úspěšně analyzovat.

Parametr s může obsahovat NumberFormatInfo.PositiveInfinitySymbolaktuální jazykové verze , NumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.NaNSymbol (porovnání řetězců se rozlišují malá a velká písmena) nebo řetězec formuláře:

[ws] [znaménko] [integral-digits,]integral-digits[.[ fractional-digits]][e[sign]exponential-digits][ws]

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

Element	Popis
ws	Řada prázdných znaků.
znaménko	Symbol záporného nebo kladného znaménka.
celočíselné číslice	Řada číselných znaků v rozsahu od 0 do 9, která určuje celočíselnou část čísla. Integrální číslice mohou chybět, pokud existují desetinné číslice.
,	Symbol oddělovače skupin specifických pro jazykovou verzi.
.	Symbol desetinné čárky specifické pro jazykovou verzi.
desetinné číslice	Řada číselných znaků v rozsahu od 0 do 9, která určuje desetinnou část čísla.
E	Velké nebo malé písmeno "e", které označuje exponenciální (vědecký) zápis.
exponenciální číslice	Řada číselných znaků v rozsahu od 0 do 9, která určuje exponent.

Další informace o numerických formátech naleznete v tématu Typy formátování.

Parametr s se interpretuje pomocí kombinace příznaků NumberStyles.Float a NumberStyles.AllowThousands. To znamená, že jsou povolené prázdné znaky a oddělovače tisíců, ale symboly měny nejsou. Pokud chcete explicitně definovat prvky (například symboly měny, oddělovače tisíců a prázdné znaky), které mohou být přítomné v s, použijte přetížení metody Double.TryParse(String, NumberStyles, IFormatProvider, Double).

Parametr s se analyzuje pomocí informací o formátování v objektu NumberFormatInfo inicializovaném pro aktuální jazykovou verzi systému. Další informace najdete v tématu NumberFormatInfo.CurrentInfo. K analýze řetězce pomocí informací o formátování některé jiné zadané jazykové verze použijte přetížení metody Double.TryParse(String, NumberStyles, IFormatProvider, Double).

Obvykle platí, že pokud předáte Double.TryParse metodě řetězec vytvořený voláním metody Double.ToString, vrátí se původní hodnota Double. Kvůli ztrátě přesnosti se však hodnoty nemusí shodovat. Kromě toho se pokus o parsování řetězcové reprezentace Double.MinValue nebo Double.MaxValue nezdaří odezvu. V rozhraní .NET Framework a .NET Core 2.2 a předchozích verzích vyvolá OverflowException. V .NET Core 3.0 a novějších verzích vrátí Double.NegativeInfinity, pokud se pokusíte analyzovat MinValue nebo Double.PositiveInfinity, pokud se pokusíte analyzovat MaxValue. Následující příklad obsahuje obrázek.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

Pokud je s v rozhraní .NET Framework a .NET Core 2.2 a starších verzích mimo rozsah datového typu Double, vyvolá metoda TryParse(String, Double)OverflowException.

V .NET Core 3.0 a novějších verzích není vyvolán žádná výjimka, pokud s je mimo rozsah datového typu Double. Ve většině případů metoda TryParse(String, Double) vypočítá výsledek Double.PositiveInfinity nebo Double.NegativeInfinity. Existuje však malá sada hodnot, které jsou považovány za blíže k maximální nebo minimální hodnotě Double než k kladnému nebo zápornému nekonečnu. V těchto případech metoda vypočítá výsledek Double.MaxValue nebo Double.MinValue.

Pokud je v parametru s během operace analýzy zjištěn oddělovač a oddělovače desetinných míst a oddělovače skupin jsou stejné, operace analýzy předpokládá, že oddělovač je oddělovač desetinných míst, nikoli oddělovač skupin. Další informace o oddělovači naleznete v tématu CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatora NumberGroupSeparator.

Viz také

Parse(String)
ToString()
analýza číselných řetězců v rozhraní .NET
Ukázka : rozhraní .NET Core WinForms (C#)
ukázka : .NET Core WinForms Formatting Utility (Visual Basic)

Platí pro

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)

Zdroj:: Double.cs

Zdroj:: Double.cs

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

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

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

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

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Double) 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: Double

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.

Platí pro

TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)

Zdroj:: Double.cs

Zdroj:: Double.cs

Zdroj:: Double.cs

Pokusí se analyzovat rozsah znaků do hodnoty.

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

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

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Double) 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: Double

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.

Platí pro

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

Zdroj:: Double.cs

Zdroj:: Double.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] double % result) = System::Numerics::INumberBase<double>::TryParse;

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

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

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Double) 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: Double

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.

Platí pro

TryParse(ReadOnlySpan<Byte>, Double)

Zdroj:: Double.cs

Zdroj:: Double.cs

Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na ekvivalent čísla s dvojitou přesností s plovoucí desetinnou čárkou.

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

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

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

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

Parametry

utf8Text: ReadOnlySpan<Byte>

Rozsah znaků UTF-8 jen pro čtení, který obsahuje číslo, které se má převést.

result: Double

Pokud tato metoda vrátí, obsahuje číslo s plovoucí desetinnou čárkou s dvojitou přesností odpovídající číselné hodnotě nebo symbolu obsaženému v utf8Text, pokud převod proběhl úspěšně nebo nula v případě selhání převodu. Převod selže, pokud je utf8TextEmpty nebo není v platném formátu. 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.

Platí pro

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

Zdroj:: Double.cs

Zdroj:: Double.cs

Zdroj:: Double.cs

Převede rozsah znaků obsahující řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. 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] double % result);

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

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

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

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

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

Parametry

s: ReadOnlySpan<Char>

Rozsah znaků jen pro čtení, který obsahuje číslo, které chcete převést.

style: NumberStyles

Bitové kombinace NumberStyles hodnot, které označují povolený formát s. Typická hodnota pro zadání je Float v kombinaci s AllowThousands.

provider: IFormatProvider

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

result: Double

Pokud tato metoda vrátí a pokud převod proběhl úspěšně, obsahuje číslo s plovoucí desetinnou čárkou s dvojitou přesností odpovídající číselné hodnotě nebo symbolu obsaženému v s. Obsahuje nulu, pokud převod selhal. Převod selže, pokud je parametr snull, prázdný znak rozpětí nebo ne číslo ve formátu kompatibilním s style. Pokud s je platné číslo menší než Double.MinValue, result je NegativeInfinity. Pokud s je platné číslo větší než Double.MaxValue, result je PositiveInfinity. 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.

Poznámky

Platí pro

TryParse(String, NumberStyles, IFormatProvider, Double)

Zdroj:: Double.cs

Zdroj:: Double.cs

Zdroj:: Double.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. 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] double % result);

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

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

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

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

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

Parametry

s: String

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

style: NumberStyles

Bitové kombinace NumberStyles hodnot, které označují povolený formát s. Typická hodnota pro zadání je Float v kombinaci s AllowThousands.

provider: IFormatProvider

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

result: Double

Pokud tato metoda vrátí, obsahuje číslo s plovoucí desetinnou čárkou s dvojitou přesností ekvivalent číselné hodnoty nebo symbolu obsaženého v s, pokud převod proběhl úspěšně, nebo nula, pokud převod selhal. Převod selže, pokud je parametr snull nebo Empty nebo není ve formátu kompatibilním s stylenebo pokud style není platná kombinace NumberStyles konstant výčtu. Selže také v rozhraní .NET Framework nebo .NET Core 2.2 a starších verzích, pokud s 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 obsahuje hodnotu AllowHexSpecifier.

Příklady

Následující příklad ukazuje použití Double.TryParse(String, NumberStyles, IFormatProvider, Double) metoda k analýze řetězcové reprezentace čísel, které mají určitý styl a jsou formátovány pomocí konvencí konkrétní jazykové verze.

string value;
NumberStyles style;
CultureInfo culture;
double number;

// Parse currency value using en-GB culture.
value = "£1,097.63";
style = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
culture = CultureInfo.CreateSpecificCulture("en-GB");
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Converted '£1,097.63' to 1097.63.

value = "1345,978";
style = NumberStyles.AllowDecimalPoint;
culture = CultureInfo.CreateSpecificCulture("fr-FR");
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Converted '1345,978' to 1345.978.

value = "1.345,978";
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
culture = CultureInfo.CreateSpecificCulture("es-ES");
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Converted '1.345,978' to 1345.978.

value = "1 345,978";
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Unable to convert '1 345,978'.

// Parse currency value using en-GB culture.
let value = "£1,097.63"
let style = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
let culture = CultureInfo.CreateSpecificCulture "en-GB"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Converted '£1,097.63' to 1097.63.

let value = "1345,978"
let style = NumberStyles.AllowDecimalPoint
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Converted '1345,978' to 1345.978.

let value = "1.345,978"
let style = NumberStyles.AllowDecimalPoint ||| NumberStyles.AllowThousands
let culture = CultureInfo.CreateSpecificCulture("es-ES")
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Converted '1.345,978' to 1345.978.

let value = "1 345,978"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Unable to convert '1 345,978'.

Dim value As String
Dim style As NumberStyles
Dim culture As CultureInfo
Dim number As Double

' Parse currency value using en-GB culture.
value = "£1,097.63"
style = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
culture = CultureInfo.CreateSpecificCulture("en-GB")
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays: 
'       Converted '£1,097.63' to 1097.63.

value = "1345,978"
style = NumberStyles.AllowDecimalPoint
culture = CultureInfo.CreateSpecificCulture("fr-FR")
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays:
'       Converted '1345,978' to 1345.978.

value = "1.345,978"
style = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands
culture = CultureInfo.CreateSpecificCulture("es-ES")
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays: 
'       Converted '1.345,978' to 1345.978.

value = "1 345,978"
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays:
'       Unable to convert '1 345,978'.

Poznámky

Metoda TryParse je podobná metodě Parse(String, NumberStyles, IFormatProvider), s výjimkou této metody nevyvolá výjimku, pokud převod selže. Pokud je převod úspěšný, návratová hodnota je true a parametr result je nastaven na výsledek převodu. Pokud převod selže, návratová hodnota je false a parametr result je nastaven na nulu. Tím se eliminuje nutnost použít zpracování výjimek k otestování FormatException v případě, že s je neplatný a nelze ji úspěšně analyzovat.

Parametr style definuje povolený formát parametru s pro úspěšnou operaci analýzy. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu. Následující NumberStyles členy nejsou podporovány:

Parametr s může obsahovat NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolnebo NumberFormatInfo.NaNSymbol pro jazykovou verzi označenou provider. Kromě toho v závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko] [integral-digits,]integral-digits[.fractional-digits][e[sign]exponential-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é znaky. Prázdné znaky se můžou objevit na začátku `s`, pokud `style` obsahuje příznak NumberStyles.AllowLeadingWhite. Může se zobrazit na konci `s`, pokud `style` obsahuje příznak NumberStyles.AllowTrailingWhite.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyNegativePattern nebo NumberFormatInfo.CurrencyPositivePattern vlastnosti NumberFormatInfo objekt vrácený IFormatProvider.GetFormat metodou parametru `provider`. Symbol měny se může zobrazit v `s`, pokud `style` obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku `s`, pokud `style` obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit na konci `s`, pokud `style` obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v `s` k označení záporné hodnoty, pokud `style` obsahuje příznak NumberStyles.AllowParentheses.
celočíselné číslice	Řada číslic v rozsahu od 0 do 9, která určuje celočíselnou část čísla. Integrální číslice mohou chybět, pokud existují desetinné číslice.
,	Symbol oddělovače tisíců specifických pro jazykovou verzi. Symbol oddělovače tisíců aktuální jazykové verze se může objevit v `s`, pokud `style` obsahuje příznak NumberStyles.AllowThousands.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v `s`, pokud `style` obsahuje příznak NumberStyles.AllowDecimalPoint.
desetinné číslice	Řada číslic v rozsahu od 0 do 9, která určuje desetinnou část čísla. Desetinné číslice se můžou objevit v `s`, pokud `style` obsahuje příznak NumberStyles.AllowDecimalPoint.
e	Znak e nebo E, který označuje, že `s` může představovat číslo pomocí exponenciálního zápisu. Parametr `s` může představovat číslo v exponenciálním zápisu, pokud styl obsahuje příznak NumberStyles.AllowExponent.
exponenciální číslice	Řada číslic v rozsahu od 0 do 9, která určuje exponent.

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 pouze s číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje, pokud je v rozsahu typu Double. Zbývající System.Globalization.NumberStyles členy ovládací prvky, které mohou být, ale nemusí být přítomny ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé příznaky NumberStyles ovlivňují prvky, které mohou být přítomny v s.

Hodnota NumberStyles	Prvky povolené v s kromě číslic
None	celočíselné číslice prvek.
AllowDecimalPoint	. a desetinné číslice prvky.
AllowExponent	Parametr `s` může také použít exponenciální zápis. Tento příznak sám podporuje hodnoty ve formuláři celočíselné čísliceEexponenciální číslice; Další příznaky jsou potřeba k úspěšnému parsování řetězců v exponenciálním zápisu s takovými prvky, jako jsou kladné nebo záporné znaménka a symboly desetinné čárky.
AllowLeadingWhite	Prvek ws na začátku `s`.
AllowTrailingWhite	Prvek ws na konci `s`.
AllowLeadingSign	Znak prvek na začátku `s`.
AllowTrailingSign	Znak prvek na konci `s`.
AllowParentheses	Znak prvek ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Prvek ,.
AllowCurrencySymbol	Prvek $.
Currency	Všichni. Parametr `s` nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo konci `s`, znak na začátku `s`a . symbol. Parametr `s` může také použít exponenciální zápis.
Number	Prvky `ws`, `sign`, oddělovač tisíců (,), a desetinná čárka (.).
Any	Všechny styly s výjimkou `s` nemohou představovat šestnáctkové číslo.

Parametr provider je IFormatProvider implementace, například NumberFormatInfo nebo objekt CultureInfo. Parametr provider poskytuje informace specifické pro jazykovou verzi používané při analýze. Pokud je providernull nebo objekt NumberFormatInfo nelze získat, použijí se informace o formátu aktuální jazykové verze.

Převod selže, pokud je parametr snull nebo není číselnou hodnotou, parametr provider nepřináší objekt NumberFormatInfo nebo parametr style není kombinací bitových příznaků z výčtu NumberStyles.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

Pokud je s v rozhraní .NET Framework a .NET Core 2.2 a starších verzích mimo rozsah datového typu Double, vyvolá metoda Double.TryParse(String, NumberStyles, IFormatProvider, Double)OverflowException.

V .NET Core 3.0 a novějších verzích není vyvolán žádná výjimka, pokud s je mimo rozsah datového typu Double. Ve většině případů metoda Double.TryParse(String, NumberStyles, IFormatProvider, Double) vypočítá výsledek Double.PositiveInfinity nebo Double.NegativeInfinity. Existuje však malá sada hodnot, které jsou považovány za blíže k maximální nebo minimální hodnotě Double než k kladnému nebo zápornému nekonečnu. V těchto případech metoda vypočítá výsledek Double.MaxValue nebo Double.MinValue.

Pokud je v parametru s během operace analýzy zjištěn oddělovač a platné oddělovače desetinných míst nebo čísel a oddělovačů skupin jsou stejné, operace analýzy předpokládá, že oddělovač je oddělovač desetinných míst místo oddělovače skupiny. Další informace o oddělovači naleznete v tématu CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatora NumberGroupSeparator.

Viz také

ToString()
analýza číselných řetězců v rozhraní .NET

Platí pro

Sdílet prostřednictvím

Double.TryParse Metoda

Definice

Přetížení

Poznámky

TryParse(String, IFormatProvider, Double)

Parametry

Návraty

Platí pro

TryParse(ReadOnlySpan<Char>, Double)

Parametry

Návraty

Poznámky

Platí pro

TryParse(String, Double)

Parametry

Návraty

Příklady

Poznámky

Viz také

Platí pro

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)

Parametry

Návraty

Platí pro

TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)

Parametry

Návraty

Platí pro

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

Parametry

Návraty

Platí pro

TryParse(ReadOnlySpan<Byte>, Double)

Parametry

Návraty

Platí pro

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

Parametry

Návraty

Poznámky

Platí pro

TryParse(String, NumberStyles, IFormatProvider, Double)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Váš názor

Další materiály