Double.TryParse Metoda
Definice
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
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 s
null
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
true
, pokud byl s
úspěšně převeden; jinak false
.
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í.
Platí pro
TryParse(String, Double)
- Zdroj:
- Double.cs
- Zdroj:
- Double.cs
- Zdroj:
- Double.cs
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ý.
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 s
null
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
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
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í.
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
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
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
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 utf8Text
Empty 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
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 s
null
, 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
true
, pokud byl s
úspěšně převeden; jinak false
.
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í.
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 s
null
nebo Empty nebo není ve formátu kompatibilním s style
nebo 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
true
, pokud byl s
úspěšně převeden; jinak false
.
Výjimky
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
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í.
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ě style
můž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 provider
null
nebo objekt NumberFormatInfo nelze získat, použijí se informace o formátu aktuální jazykové verze.
Převod selže, pokud je parametr s
null
nebo není číselnou hodnotou, parametr provider
nepřináší objekt NumberFormatInfo nebo parametr style
není kombinací bitových příznaků z výčtu NumberStyles.
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 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
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro