Single.Parse 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ězcové vyjádření čísla na odpovídající číslo s jednoduchou přesností a plovoucí desetinnou čárkou.
Přetížení
Parse(String) |
Převede řetězcové vyjádření čísla na odpovídající číslo s jednoduchou přesností a plovoucí desetinnou čárkou. |
Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Parsuje rozsah znaků UTF-8 na hodnotu. |
Parse(ReadOnlySpan<Char>, IFormatProvider) |
Parsuje rozsah znaků na hodnotu. |
Parse(String, NumberStyles) |
Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho ekvivalent čísla s plovoucí desetinnou čárkou s jednou přesností. |
Parse(String, IFormatProvider) |
Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho ekvivalent čísla s plovoucí desetinnou čárkou s jednou přesností. |
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Parsuje rozsah znaků UTF-8 na hodnotu. |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Převede znakové rozpětí, které obsahuje řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho ekvivalent s plovoucí desetinnou čárkou s jednou přesností. |
Parse(String, NumberStyles, IFormatProvider) |
Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho ekvivalent čísla s plovoucí desetinnou čárkou s jednou přesností. |
Poznámky
V .NET Core 3.0 a novějších verzích se hodnoty, které jsou pro reprezentaci příliš velké, zaokrouhlují na PositiveInfinity nebo NegativeInfinity podle požadavků specifikace IEEE 754. V předchozích verzích, včetně rozhraní .NET Framework, analýza hodnoty, která byla příliš velká na to, aby reprezentovala, způsobila selhání.
Parse(String)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Převede řetězcové vyjádření čísla na odpovídající číslo s jednoduchou přesností a plovoucí desetinnou čárkou.
public:
static float Parse(System::String ^ s);
public static float Parse (string s);
static member Parse : string -> single
Public Shared Function Parse (s As String) As Single
Parametry
- s
- String
Řetězec obsahující číslo k převedení.
Návraty
Číslo s plovoucí desetinou čárkou s jednou přesností odpovídající číselné hodnotě nebo symbolu zadanému v s
.
Výjimky
s
je null
.
s
nepředstavuje číslo v platném formátu.
.NET Framework a .NET Core 2.2 a starší verze pouze: s
představuje číslo menší než Single.MinValue nebo větší než Single.MaxValue.
Příklady
Následující příklad používá metodu Parse(String) k převodu pole řetězců na ekvivalentní Single hodnoty.
using System;
public class Example
{
public static void Main()
{
string[] values = { "100", "(100)", "-123,456,789", "123.45e+6",
"+500", "5e2", "3.1416", "600.", "-.123",
"-Infinity", "-1E-16", Double.MaxValue.ToString(),
Single.MinValue.ToString(), String.Empty };
foreach (string value in values)
{
try {
float number = Single.Parse(value);
Console.WriteLine("{0} -> {1}", value, number);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in a valid format.", value);
}
catch (OverflowException) {
Console.WriteLine("{0} is outside the range of a Single.", value);
}
}
}
}
// The example displays the following output:
// 100 -> 100
// '(100)' is not in a valid format.
// -123,456,789 -> -1.234568E+08
// 123.45e+6 -> 1.2345E+08
// +500 -> 500
// 5e2 -> 500
// 3.1416 -> 3.1416
// 600. -> 600
// -.123 -> -0.123
// -Infinity -> -Infinity
// -1E-16 -> -1E-16
// 1.79769313486232E+308 is outside the range of a Single.
// -3.402823E+38 -> -3.402823E+38
// '' is not in a valid format.
open System
let values =
[| "100"; "(100)"; "-123,456,789"; "123.45e+6"
"+500"; "5e2"; "3.1416"; "600."; "-.123"
"-Infinity"; "-1E-16"; string Double.MaxValue
string Single.MinValue; String.Empty |]
for value in values do
try
let number = Single.Parse value
printfn $"{value} -> {number}"
with
| :? FormatException ->
printfn $"'{value}' is not in a valid format."
| :? OverflowException ->
printfn $"{value} is outside the range of a Single."
// The example displays the following output:
// 100 -> 100
// '(100)' is not in a valid format.
// -123,456,789 -> -1.234568E+08
// 123.45e+6 -> 1.2345E+08
// +500 -> 500
// 5e2 -> 500
// 3.1416 -> 3.1416
// 600. -> 600
// -.123 -> -0.123
// -Infinity -> -Infinity
// -1E-16 -> -1E-16
// 1.79769313486232E+308 is outside the range of a Single.
// -3.402823E+38 -> -3.402823E+38
// '' is not in a valid format.
Module Example
Public Sub Main()
Dim values() As String = { "100", "(100)", "-123,456,789", "123.45e+6", _
"+500", "5e2", "3.1416", "600.", "-.123", _
"-Infinity", "-1E-16", Double.MaxValue.ToString(), _
Single.MinValue.ToString(), String.Empty }
For Each value As String In values
Try
Dim number As Single = Single.Parse(value)
Console.WriteLine("{0} -> {1}", value, number)
Catch e As FormatException
Console.WriteLine("'{0}' is not in a valid format.", value)
Catch e As OverflowException
Console.WriteLine("{0} is outside the range of a Single.", value)
End Try
Next
End Sub
End Module
' The example displays the following output:
' 100 -> 100
' '(100)' is not in a valid format.
' -123,456,789 -> -1.234568E+08
' 123.45e+6 -> 1.2345E+08
' +500 -> 500
' 5e2 -> 500
' 3.1416 -> 3.1416
' 600. -> 600
' -.123 -> -0.123
' -Infinity -> -Infinity
' -1E-16 -> -1E-16
' 1.79769313486232E+308 is outside the range of a Single.
' -3.402823E+38 -> -3.402823E+38
' '' is not in a valid format.
Poznámky
V .NET Core 3.0 a novějších verzích se hodnoty, které jsou pro reprezentaci příliš velké, zaokrouhlují na PositiveInfinity nebo NegativeInfinity podle požadavků specifikace IEEE 754. V předchozích verzích, včetně rozhraní .NET Framework, analýza hodnoty, která byla příliš velká na to, aby reprezentovala, způsobila selhání.
Parametr s
může obsahovat aktuální jazykovou PositiveInfinitySymbolverzi , NegativeInfinitySymbol, NaNSymbolnebo řetězec formuláře:
[ws] [sign] [integral-digits[,]] integral-digits[.[desetinné číslice]] [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 | Řada prázdných znaků. |
sign | Symbol záporného nebo kladného znaménka. Platné znakové znaky jsou určeny vlastnostmi NumberFormatInfo.NegativeSign a NumberFormatInfo.PositiveSign aktuální jazykové verze. Lze použít pouze počáteční znaménko. |
číslice-základu | Řada číslic od 0 do 9, které určují základní část čísla. Spuštění integrálních číslic lze rozdělit pomocí symbolu oddělovače skupin. V některých kulturách například čárka (,) odděluje skupiny tisíců. Prvek integral-digits může chybět, pokud řetězec obsahuje prvek fractional-digits . |
, | Symbol oddělovače tisíců, specifický pro jazykovou verzi. |
. | Symbol desetinné čárky specifický pro jazykovou verzi. |
desetinné-číslice | Řada číslic od 0 do 9, které určují desetinnou část čísla. |
E | Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. |
číslice-exponentu | Řada číslic od 0 do 9, které určují exponent. |
Parametr s
se interpretuje pomocí kombinace NumberStyles.Float příznaků a NumberStyles.AllowThousands . To znamená, že mezery a oddělovače tisíců jsou povoleny, ale symboly měny nikoli. Chcete-li explicitně definovat prvky (například symboly měny, oddělovače tisíců a prázdné znaky), které mohou být přítomny v s
, použijte Parse(String, NumberStyles) přetížení metody.
Parametr s
se analyzuje pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální systémovou jazykovou verzi. Další informace naleznete v tématu CurrentInfo. Pokud chcete analyzovat řetězec pomocí informací o formátování konkrétní jazykové verze, použijte metodu Parse(String, IFormatProvider) nebo Parse(String, NumberStyles, IFormatProvider) .
Obvykle, pokud předáte Parse metodě řetězec, který je vytvořen voláním ToString metody, je vrácena původní Single hodnota. Z důvodu ztráty přesnosti nemusí být hodnoty stejné.
Pokud s
je mimo rozsah datového Single typu, metoda vyvolá objekt OverflowException v rozhraní .NET Framework a .NET Core 2.2 a starších verzích. V .NET Core 3.0 a novějších verzích vrátí Single.NegativeInfinity , pokud s
je menší než Single.MinValue a Single.PositiveInfinity pokud s
je větší než Single.MaxValue.
Pokud je v parametru s
během operace analýzy nalezen oddělovač a příslušné oddělovače desetinných míst měny nebo čísla jsou stejné, operace parse předpokládá, že oddělovač je oddělovačem desetinných míst, nikoli oddělovačem skupin. Další informace o oddělovači najdete v tématech CurrencyDecimalSeparator, CurrencyGroupSeparatorNumberDecimalSeparator, a NumberGroupSeparator.
Viz také
Platí pro
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Parsuje rozsah znaků UTF-8 na hodnotu.
public:
static float Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<float>::Parse;
public static float Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> single
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Single
Parametry
- utf8Text
- ReadOnlySpan<Byte>
Rozsah znaků UTF-8, které se mají analyzovat.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .utf8Text
Návraty
Výsledek analýzy utf8Text
.
Implementuje
Platí pro
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Parsuje rozsah znaků na hodnotu.
public:
static float Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<float>::Parse;
public static float Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> single
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Single
Parametry
- s
- ReadOnlySpan<Char>
Rozsah znaků, které se mají analyzovat.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
Návraty
Výsledek analýzy s
.
Implementuje
Platí pro
Parse(String, NumberStyles)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho ekvivalent čísla s plovoucí desetinnou čárkou s jednou přesností.
public:
static float Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static float Parse (string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> single
Public Shared Function Parse (s As String, style As NumberStyles) As Single
Parametry
- s
- String
Řetězec obsahující číslo k převedení.
- style
- NumberStyles
Bitové kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s
. Typická hodnota, která se má zadat, je Float kombinována s AllowThousandshodnotou .
Návraty
Číslo s plovoucí desetinou čárkou s jednou přesností, které odpovídá číselné hodnotě nebo symbolu zadanému v s
.
Výjimky
s
je null
.
s
není číslo v platném formátu.
.NET Framework a .NET Core 2.2 a starší verze pouze: s
Představuje číslo, které je menší než Single.MinValue nebo větší než Single.MaxValue.
Příklady
Následující příklad používá metodu Parse(String, NumberStyles) k analýze řetězcových Single reprezentací hodnot. Příklad používá informace o formátování pro jazykovou verzi en-US.
using System;
using System.Globalization;
using System.Threading;
public class ParseString
{
public static void Main()
{
// Set current thread culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
string value;
NumberStyles styles;
// Parse a string in exponential notation with only the AllowExponent flag.
value = "-1.063E-02";
styles = NumberStyles.AllowExponent;
ShowNumericValue(value, styles);
// Parse a string in exponential notation
// with the AllowExponent and Number flags.
styles = NumberStyles.AllowExponent | NumberStyles.Number;
ShowNumericValue(value, styles);
// Parse a currency value with leading and trailing white space, and
// white space after the U.S. currency symbol.
value = " $ 6,164.3299 ";
styles = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
ShowNumericValue(value, styles);
// Parse negative value with thousands separator and decimal.
value = "(4,320.64)";
styles = NumberStyles.AllowParentheses | NumberStyles.AllowTrailingSign |
NumberStyles.Float;
ShowNumericValue(value, styles);
styles = NumberStyles.AllowParentheses | NumberStyles.AllowTrailingSign |
NumberStyles.Float | NumberStyles.AllowThousands;
ShowNumericValue(value, styles);
}
private static void ShowNumericValue(string value, NumberStyles styles)
{
Single number;
try
{
number = Single.Parse(value, styles);
Console.WriteLine("Converted '{0}' using {1} to {2}.",
value, styles.ToString(), number);
}
catch (FormatException)
{
Console.WriteLine("Unable to parse '{0}' with styles {1}.",
value, styles.ToString());
}
Console.WriteLine();
}
}
// The example displays the following output to the console:
// Unable to parse '-1.063E-02' with styles AllowExponent.
//
// Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
//
// Converted ' $ 6,164.3299 ' using Number, AllowCurrencySymbol to 6164.3299.
//
// Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
//
// Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.
open System
open System.Globalization
open System.Threading
let showNumericValue value (styles: NumberStyles) =
try
let number = Single.Parse(value, styles)
printfn $"Converted '{value}' using {styles} to {number}."
with :? FormatException ->
printfn $"Unable to parse '{value}' with styles {styles}."
printfn ""
[<EntryPoint>]
let main _ =
// Set current thread culture to en-US.
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
// Parse a string in exponential notation with only the AllowExponent flag.
let value = "-1.063E-02"
let styles = NumberStyles.AllowExponent
showNumericValue value styles
// Parse a string in exponential notation
// with the AllowExponent and Number flags.
let styles = NumberStyles.AllowExponent ||| NumberStyles.Number
showNumericValue value styles
// Parse a currency value with leading and trailing white space, and
// white space after the U.S. currency symbol.
let value = " $ 6,164.3299 "
let styles = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
showNumericValue value styles
// Parse negative value with thousands separator and decimal.
let value = "(4,320.64)"
let styles = NumberStyles.AllowParentheses ||| NumberStyles.AllowTrailingSign ||| NumberStyles.Float
showNumericValue value styles
let styles = NumberStyles.AllowParentheses ||| NumberStyles.AllowTrailingSign ||| NumberStyles.Float ||| NumberStyles.AllowThousands
showNumericValue value styles
0
// The example displays the following output to the console:
// Unable to parse '-1.063E-02' with styles AllowExponent.
//
// Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
//
// Converted ' $ 6,164.3299 ' using Number, AllowCurrencySymbol to 6164.3299.
//
// Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
//
// Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.
Imports System.Globalization
Imports System.Threading
Module ParseStrings
Public Sub Main()
' Set current thread culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Dim value As String
Dim styles As NumberStyles
' Parse a string in exponential notation with only the AllowExponent flag.
value = "-1.063E-02"
styles = NumberStyles.AllowExponent
ShowNumericValue(value, styles)
' Parse a string in exponential notation
' with the AllowExponent and Number flags.
styles = NumberStyles.AllowExponent Or NumberStyles.Number
ShowNumericValue(value, styles)
' Parse a currency value with leading and trailing white space, and
' white space after the U.S. currency symbol.
value = " $ 6,164.3299 "
styles = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
ShowNumericValue(value, styles)
' Parse negative value with thousands separator and decimal.
value = "(4,320.64)"
styles = NumberStyles.AllowParentheses Or NumberStyles.AllowTrailingSign _
Or NumberStyles.Float
ShowNumericValue(value, styles)
styles = NumberStyles.AllowParentheses Or NumberStyles.AllowTrailingSign _
Or NumberStyles.Float Or NumberStyles.AllowThousands
ShowNumericValue(value, styles)
End Sub
Private Sub ShowNumericValue(value As String, styles As NumberStyles)
Dim number As Single
Try
number = Single.Parse(value, styles)
Console.WriteLine("Converted '{0}' using {1} to {2}.", _
value, styles.ToString(), number)
Catch e As FormatException
Console.WriteLine("Unable to parse '{0}' with styles {1}.", _
value, styles.ToString())
End Try
Console.WriteLine()
End Sub
End Module
' The example displays the following output to the console:
' Unable to parse '-1.063E-02' with styles AllowExponent.
'
' Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
'
' Converted ' $ 6,164.3299 ' using Number, AllowCurrencySymbol to 6164.3299.
'
' Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
'
' Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.
Poznámky
V .NET Core 3.0 a novějších verzích se hodnoty, které jsou pro reprezentaci příliš velké, zaokrouhlují na PositiveInfinity nebo NegativeInfinity podle požadavků specifikace IEEE 754. V předchozích verzích, včetně rozhraní .NET Framework, analýza hodnoty, která byla příliš velká na to, aby reprezentovala, způsobila selhání.
Parametr style
definuje prvky stylu (například prázdné znaky, oddělovače tisíců a symboly měny), které jsou povoleny v parametru s
pro úspěšné operace analýzy. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . Následující NumberStyles členové nejsou podporováni:
Parametr s
může obsahovat aktuální jazykovou PositiveInfinitySymbolverzi , NegativeInfinitySymbol, NaNSymbol. V závislosti na hodnotě style
může mít také tvar:
[ws] [$][sign][integral-digits[,]]integral-digits[.[desetinné číslice]] [E[sign]exponential-digits] [ws]
Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.
Ws Řada prázdných znaků. Prázdné místo se může zobrazit na začátku, s
pokud style
obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, s
pokud style
obsahuje NumberStyles.AllowTrailingWhite příznak.
$ Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s
, pokud style
obsahuje NumberStyles.AllowCurrencySymbol příznak.
Znamení Symbol záporného znaménka (-) nebo kladného symbolu (+). Znaménko se může zobrazit na začátku, pokud příznak obsahujeNumberStyles.AllowLeadingSign, a může se zobrazit na konci, s
pokud style
příznak obsahujeNumberStyles.AllowTrailingSign.style
s
Závorky lze v s
použít k označení záporné hodnoty, pokud style
obsahuje NumberStyles.AllowParentheses příznak.
celočíselné číslice Řada číslic v rozsahu od 0 do 9, které určují integrální část čísla. Prvek integral-digits může chybět, pokud řetězec obsahuje prvek fractional-digits .
, Oddělovač skupin specifických pro jazykovou verzi. Symbol oddělovače skupin aktuální jazykové verze se může zobrazit v s
, pokud style
obsahuje NumberStyles.AllowThousands příznak.
.
Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s
, pokud style
obsahuje NumberStyles.AllowDecimalPoint příznak.
zlomkové číslice Řada číslic v rozsahu od 0 do 9, které určují zlomkovou část čísla. Desetinné číslice se můžou zobrazit v s
, pokud style
obsahuje NumberStyles.AllowDecimalPoint příznak.
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ápisuNumberStyles.AllowExponent, pokud style
obsahuje příznak.
exponenciální číslice Řada číslic v rozsahu od 0 do 9, které určují exponent.
Poznámka
Operace analýzy ignoruje všechny ukončující ZNAKY NUL (U+0000) bez s
ohledu na hodnotu argumentu style
.
Řetězec pouze s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně analyzuje, pokud je v rozsahu Single typu. Zbývající System.Globalization.NumberStyles členové řídí prvky, které mohou být přítomny, ale nemusí být přítomny, ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles příznaky ovlivňují prvky, které mohou být přítomny v nástroji s
.
Hodnota NumberStyles | Prvky povolené s kromě číslic |
---|---|
None | Pouze prvek celočíselné číslice . |
AllowDecimalPoint | Desetinná čárka (.) a desetinné číslice elementů . |
AllowExponent | Znak "e" nebo "E", který označuje exponenciální zápis. Tento příznak sám o sobě podporuje hodnoty v číslicíchformuláře Ečíslice; K úspěšné parsování řetězců s prvky, jako jsou kladné nebo záporné znaménka a symboly desetinné čárky, jsou potřeba další příznaky. |
AllowLeadingWhite | Element ws na začátku souboru s . |
AllowTrailingWhite | Element ws na konci souboru s . |
AllowLeadingSign | Element sign na začátku objektu s . |
AllowTrailingSign | Element sign na konci objektu s . |
AllowParentheses | Element sign ve formě závorek ohraničující číselnou hodnotu. |
AllowThousands | Prvek oddělovače tisíců (,). |
AllowCurrencySymbol | Prvek měny ($). |
Currency | Všechny prvky.
s Nemůže však představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu. |
Float | Element ws na začátku nebo na konci s , znaménko na začátku s a symbol desetinné čárky (.). Parametr s může také použít exponenciální notaci. |
Number | Oddělovač ws tisíců (,) a desetinná čárka (.) elementy , sign |
Any | Všechny prvky. Nemůže však s představovat šestnáctkové číslo. |
Mezi příklady s
patří "100", "-123,456,789", "123,45e+6", "+500", "5e2", "3.1416", "600.", "-.123" a "-Infinity".
Parametr s
se analyzuje pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální jazykovou verzi systému. Pokud chcete určit jazykovou verzi, jejíž informace o formátování se používají pro operaci analýzy, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.
Obvykle, pokud předáte Parse metodě řetězec, který je vytvořen voláním ToString metody, je vrácena původní Single hodnota. Z důvodu ztráty přesnosti nemusí být hodnoty stejné.
Pokud s
je mimo rozsah datového Single typu, metoda vyvolá objekt OverflowException v rozhraní .NET Framework a .NET Core 2.2 a starších verzích. V .NET Core 3.0 a novějších verzích vrátí Single.NegativeInfinity , pokud s
je menší než Single.MinValue a Single.PositiveInfinity pokud s
je větší než Single.MaxValue.
Pokud je v parametru s
během operace analýzy nalezen oddělovač a příslušné oddělovače desetinných míst měny nebo čísla jsou stejné, operace parse předpokládá, že oddělovač je oddělovačem desetinných míst, nikoli oddělovačem skupin. Další informace o oddělovači najdete v tématech CurrencyDecimalSeparator, CurrencyGroupSeparatorNumberDecimalSeparator, a NumberGroupSeparator.
Viz také
Platí pro
Parse(String, IFormatProvider)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho ekvivalent čísla s plovoucí desetinnou čárkou s jednou přesností.
public:
static float Parse(System::String ^ s, IFormatProvider ^ provider);
public:
static float Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<float>::Parse;
public static float Parse (string s, IFormatProvider provider);
public static float Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> single
Public Shared Function Parse (s As String, provider As IFormatProvider) As Single
Parametry
- s
- String
Řetězec obsahující číslo k převedení.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
Návraty
Číslo s plovoucí desetinou čárkou s jednou přesností odpovídající číselné hodnotě nebo symbolu zadanému v s
.
Implementuje
Výjimky
s
je null
.
s
nepředstavuje číslo v platném formátu.
.NET Framework a .NET Core 2.2 a starší verze pouze: s
představuje číslo menší než Single.MinValue nebo větší než Single.MaxValue.
Příklady
V následujícím příkladu je obslužná rutina události kliknutí na tlačítko webového formuláře. Používá pole vrácené HttpRequest.UserLanguages vlastností k určení národního prostředí uživatele. Potom vytvoří instanci objektu CultureInfo , který odpovídá danému národnímu prostředí. Objekt NumberFormatInfo , který patří danému objektu, CultureInfo se pak předá Parse(String, IFormatProvider) metodě, která převede vstup uživatele na Single hodnotu.
protected void OkToSingle_Click(object sender, EventArgs e)
{
string locale;
float number;
CultureInfo culture;
// Return if string is empty
if (String.IsNullOrEmpty(this.inputNumber.Text))
return;
// Get locale of web request to determine possible format of number
if (Request.UserLanguages.Length == 0)
return;
locale = Request.UserLanguages[0];
if (String.IsNullOrEmpty(locale))
return;
// Instantiate CultureInfo object for the user's locale
culture = new CultureInfo(locale);
// Convert user input from a string to a number
try
{
number = Single.Parse(this.inputNumber.Text, culture.NumberFormat);
}
catch (FormatException)
{
return;
}
catch (Exception)
{
return;
}
// Output number to label on web form
this.outputNumber.Text = "Number is " + number.ToString();
}
Protected Sub OkToSingle_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToSingle.Click
Dim locale As String
Dim culture As CultureInfo
Dim number As Single
' Return if string is empty
If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub
' Get locale of web request to determine possible format of number
If Request.UserLanguages.Length = 0 Then Exit Sub
locale = Request.UserLanguages(0)
If String.IsNullOrEmpty(locale) Then Exit Sub
' Instantiate CultureInfo object for the user's locale
culture = New CultureInfo(locale)
' Convert user input from a string to a number
Try
number = Single.Parse(Me.inputNumber.Text, culture.NumberFormat)
Catch ex As FormatException
Exit Sub
Catch ex As OverflowException
Exit Sub
End Try
' Output number to label on web form
Me.outputNumber.Text = "Number is " & number.ToString()
End Sub
Poznámky
V .NET Core 3.0 a novějších verzích se hodnoty, které jsou pro reprezentaci příliš velké, zaokrouhlují na PositiveInfinity nebo NegativeInfinity podle požadavků specifikace IEEE 754. V předchozích verzích, včetně rozhraní .NET Framework, analýza hodnoty, která byla příliš velká na to, aby reprezentovala, způsobila selhání.
Toto přetížení se obvykle používá k převodu textu, který lze formátovat různými způsoby, na Single hodnotu. Například jej lze použít k převodu textu zadaného uživatelem do textového pole HTML na číselnou hodnotu.
Parametr s
se interpretuje pomocí kombinace NumberStyles.Float příznaků a NumberStyles.AllowThousands . Parametr s
může obsahovat NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolnebo NumberFormatInfo.NaNSymbol pro jazykovou verzi určenou nástrojem provider
nebo může obsahovat řetězec formuláře:
[ws] [sign] integral-digits[.[desetinné číslice]] [E[sign]exponential-digits] [ws]
Volitelné prvky jsou uvedeny v hranatých závorkách ( [ a ] ). Prvky, které obsahují číslice se skládají z řady číselných znaků od 0 do 9.
Element | Popis |
---|---|
Ws | Posloupnost znaků mezer. |
sign | Symbol záporného znaménka (-) nebo symbol kladného znaménka (+). |
číslice-základu | Řada číslic od 0 do 9, které určují základní část čísla. Spuštění integrálních číslic lze rozdělit pomocí symbolu oddělovače skupin. V některých kulturách například čárka (,) odděluje skupiny tisíců. Prvek integral-digits může chybět, pokud řetězec obsahuje prvek fractional-digits . |
. | Symbol desetinné čárky specifický pro jazykovou verzi. |
desetinné-číslice | Řada číslic od 0 do 9, které určují desetinnou část čísla. |
E | Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. |
číslice-exponentu | Řada číslic od 0 do 9, které určují exponent. |
Další informace o číselných formátech najdete v tématu Typy formátování .
Parametr provider
je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace o formátování specifické pro jazykovou verzi. Při vyvolání Parse(String, IFormatProvider) metody volá metodu parametru GetFormatprovider
a předá jí Type objekt, který představuje NumberFormatInfo typ. Metoda GetFormat pak vrátí NumberFormatInfo objekt, který poskytuje informace o formátu parametru s
. Existují tři způsoby, jak použít provider
parametr k poskytnutí informací o vlastním formátování do operace parsování:
Můžete předat CultureInfo objekt, který představuje jazykovou verzi, která poskytuje informace o formátování. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace o číselném formátování pro danou jazykovou verzi.
Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o číselném formátování. (Jeho implementace GetFormat pouze vrátí sama sebe.)
Můžete předat vlastní objekt, který implementuje IFormatProvider. Jeho GetFormat metoda vytvoří instanci a vrátí NumberFormatInfo objekt, který poskytuje informace o formátování.
Pokud provider
je null
nebo NumberFormatInfo nelze získat, použijí se informace o formátování pro aktuální systémovou jazykovou verzi.
Pokud s
je mimo rozsah datového Single typu, metoda vyvolá objekt OverflowException v rozhraní .NET Framework a .NET Core 2.2 a starších verzích. V .NET Core 3.0 a novějších verzích vrátí Single.NegativeInfinity , pokud s
je menší než Single.MinValue a Single.PositiveInfinity pokud s
je větší než Single.MaxValue.
Pokud je v parametru s
během operace analýzy nalezen oddělovač a příslušné oddělovače desetinných míst měny nebo čísla jsou stejné, operace parse předpokládá, že oddělovač je oddělovačem desetinných míst, nikoli oddělovačem skupin. Další informace o oddělovači najdete v tématech CurrencyDecimalSeparator, CurrencyGroupSeparatorNumberDecimalSeparator, a NumberGroupSeparator.
Mezi příklady s
patří "100", "-123,456,789", "123,45e+6", "+500", "5e2", "3.1416", "600.", "-.123" a "-Infinity".
Viz také
Platí pro
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Parsuje rozsah znaků UTF-8 na hodnotu.
public static float Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> single
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, Optional provider As IFormatProvider = Nothing) As Single
Parametry
- utf8Text
- ReadOnlySpan<Byte>
Rozsah znaků UTF-8, které se mají analyzovat.
- style
- NumberStyles
Bitové kombinace stylů čísel, které se můžou vyskytovat v nástroji utf8Text
.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .utf8Text
Návraty
Výsledek analýzy utf8Text
.
Implementuje
Platí pro
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Převede znakové rozpětí, které obsahuje řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho ekvivalent s plovoucí desetinnou čárkou s jednou přesností.
public static float Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);
public static float Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> single
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, Optional provider As IFormatProvider = Nothing) As Single
Parametry
- s
- ReadOnlySpan<Char>
Rozsah znaků obsahující číslo, které se má převést.
- style
- NumberStyles
Bitové kombinace hodnot výčtu, které označují prvky stylu, které mohou být přítomny v s
. Typická hodnota, která se má zadat, je Float kombinována s AllowThousandshodnotou .
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
Návraty
Číslo s plovoucí desetinou čárkou s jednou přesností, které odpovídá číselné hodnotě nebo symbolu zadanému v s
.
Implementuje
Výjimky
s
nepředstavuje číselnou hodnotu.
Poznámky
V .NET Core 3.0 a novějších verzích se hodnoty, které jsou pro reprezentaci příliš velké, zaokrouhlují na PositiveInfinity nebo NegativeInfinity podle požadavků specifikace IEEE 754. V předchozích verzích, včetně rozhraní .NET Framework, analýza hodnoty, která byla příliš velká na to, aby reprezentovala, způsobila selhání.
Pokud s
je mimo rozsah datového Single typu, vrátí Single.NegativeInfinity metoda, pokud s
je menší než Single.MinValue a Single.PositiveInfinity pokud s
je větší než Single.MaxValue.
Platí pro
Parse(String, NumberStyles, IFormatProvider)
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
- Zdroj:
- Single.cs
Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho ekvivalent čísla s plovoucí desetinnou čárkou s jednou přesností.
public:
static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<float>::Parse;
public static float Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static float Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> single
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Single
Parametry
- s
- String
Řetězec obsahující číslo k převedení.
- style
- NumberStyles
Bitové kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s
. Typická hodnota, která se má zadat, je Float kombinována s AllowThousandshodnotou .
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
Návraty
Číslo s plovoucí desetinou čárkou s jednou přesností odpovídající číselné hodnotě nebo symbolu zadanému v s
.
Implementuje
Výjimky
s
je null
.
s
nepředstavuje číselnou hodnotu.
.NET Framework a .NET Core 2.2 a starší verze pouze: s
Představuje číslo, které je menší než Single.MinValue nebo větší než Single.MaxValue.
Příklady
Následující příklad kódu používá metodu Parse(String, NumberStyles, IFormatProvider) k analýze řetězcových reprezentací Single hodnot. Každý řetězec v poli se analyzuje pomocí konvencí formátování en-US, nl-NL a vlastní jazykové verze. Vlastní jazyková verze definuje symbol oddělovače skupin jako podtržítko ("_") a velikost skupiny jako dvě.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
// Define an array of string values.
string[] values = { " 987.654E-2", " 987,654E-2", "(98765,43210)",
"9,876,543.210", "9.876.543,210", "98_76_54_32,19" };
// Create a custom culture based on the invariant culture.
CultureInfo ci = new CultureInfo("");
ci.NumberFormat.NumberGroupSizes = new int[] { 2 };
ci.NumberFormat.NumberGroupSeparator = "_";
// Define an array of format providers.
CultureInfo[] providers = { new CultureInfo("en-US"),
new CultureInfo("nl-NL"), ci };
// Define an array of styles.
NumberStyles[] styles = { NumberStyles.Currency, NumberStyles.Float };
// Iterate the array of format providers.
foreach (CultureInfo provider in providers)
{
Console.WriteLine("Parsing using the {0} culture:",
provider.Name == String.Empty ? "Invariant" : provider.Name);
// Parse each element in the array of string values.
foreach (string value in values)
{
foreach (NumberStyles style in styles)
{
try {
float number = Single.Parse(value, style, provider);
Console.WriteLine(" {0} ({1}) -> {2}",
value, style, number);
}
catch (FormatException) {
Console.WriteLine(" '{0}' is invalid using {1}.", value, style);
}
catch (OverflowException) {
Console.WriteLine(" '{0}' is out of the range of a Single.", value);
}
}
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// Parsing using the en-US culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the nl-NL culture:
// ' 987.654E-2' is invalid using Currency.
// ' 987.654E-2' is invalid using Float.
// ' 987,654E-2' is invalid using Currency.
// 987,654E-2 (Float) -> 9.87654
// (98765,43210) (Currency) -> -98765.43
// '(98765,43210)' is invalid using Float.
// '9,876,543.210' is invalid using Currency.
// '9,876,543.210' is invalid using Float.
// 9.876.543,210 (Currency) -> 9876543
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the Invariant culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// 98_76_54_32,19 (Currency) -> 9.876543E+09
// '98_76_54_32,19' is invalid using Float.
open System
open System.Globalization
// Define a list of string values.
let values =
[ " 987.654E-2"; " 987,654E-2"; "(98765,43210)"
"9,876,543.210"; "9.876.543,210"; "98_76_54_32,19" ]
// Create a custom culture based on the invariant culture.
let ci = CultureInfo ""
ci.NumberFormat.NumberGroupSizes <- [| 2 |]
ci.NumberFormat.NumberGroupSeparator <- "_"
// Define a list of format providers.
let providers =
[ CultureInfo "en-US"
CultureInfo "nl-NL"
ci ]
// Define a list of styles.
let styles = [ NumberStyles.Currency; NumberStyles.Float ]
// Iterate the list of format providers.
for provider in providers do
printfn $"""Parsing using the {if provider.Name = String.Empty then "Invariant" else provider.Name} culture:"""
// Parse each element in the array of string values.
for value in values do
for style in styles do
try
let number = Single.Parse(value, style, provider)
printfn $" {value} ({style}) -> {number}"
with
| :? FormatException ->
printfn $" '{value}' is invalid using {style}."
| :? OverflowException ->
printfn $" '{value}' is out of the range of a Single."
printfn ""
// The example displays the following output:
// Parsing using the en-US culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the nl-NL culture:
// ' 987.654E-2' is invalid using Currency.
// ' 987.654E-2' is invalid using Float.
// ' 987,654E-2' is invalid using Currency.
// 987,654E-2 (Float) -> 9.87654
// (98765,43210) (Currency) -> -98765.43
// '(98765,43210)' is invalid using Float.
// '9,876,543.210' is invalid using Currency.
// '9,876,543.210' is invalid using Float.
// 9.876.543,210 (Currency) -> 9876543
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the Invariant culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// 98_76_54_32,19 (Currency) -> 9.876543E+09
// '98_76_54_32,19' is invalid using Float.
Imports System.Globalization
Module Example
Public Sub Main()
' Define an array of string values.
Dim values() As String = { " 987.654E-2", " 987,654E-2", _
"(98765,43210)", "9,876,543.210", _
"9.876.543,210", "98_76_54_32,19" }
' Create a custom culture based on the invariant culture.
Dim ci As New CultureInfo("")
ci.NumberFormat.NumberGroupSizes = New Integer() { 2 }
ci.NumberFormat.NumberGroupSeparator = "_"
' Define an array of format providers.
Dim providers() As CultureInfo = { New CultureInfo("en-US"), _
New CultureInfo("nl-NL"), ci }
' Define an array of styles.
Dim styles() As NumberStyles = { NumberStyles.Currency, NumberStyles.Float }
' Iterate the array of format providers.
For Each provider As CultureInfo In providers
Console.WriteLine("Parsing using the {0} culture:", _
If(provider.Name = String.Empty, "Invariant", provider.Name))
' Parse each element in the array of string values.
For Each value As String In values
For Each style As NumberStyles In styles
Try
Dim number As Single = Single.Parse(value, style, provider)
Console.WriteLine(" {0} ({1}) -> {2}", _
value, style, number)
Catch e As FormatException
Console.WriteLine(" '{0}' is invalid using {1}.", value, style)
Catch e As OverflowException
Console.WriteLine(" '{0}' is out of the range of a Single.", value)
End Try
Next
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' Parsing using the en-US culture:
' ' 987.654E-2' is invalid using Currency.
' 987.654E-2 (Float) -> 9.87654
' ' 987,654E-2' is invalid using Currency.
' ' 987,654E-2' is invalid using Float.
' (98765,43210) (Currency) -> -9.876543E+09
' '(98765,43210)' is invalid using Float.
' 9,876,543.210 (Currency) -> 9876543
' '9,876,543.210' is invalid using Float.
' '9.876.543,210' is invalid using Currency.
' '9.876.543,210' is invalid using Float.
' '98_76_54_32,19' is invalid using Currency.
' '98_76_54_32,19' is invalid using Float.
'
' Parsing using the nl-NL culture:
' ' 987.654E-2' is invalid using Currency.
' ' 987.654E-2' is invalid using Float.
' ' 987,654E-2' is invalid using Currency.
' 987,654E-2 (Float) -> 9.87654
' (98765,43210) (Currency) -> -98765.43
' '(98765,43210)' is invalid using Float.
' '9,876,543.210' is invalid using Currency.
' '9,876,543.210' is invalid using Float.
' 9.876.543,210 (Currency) -> 9876543
' '9.876.543,210' is invalid using Float.
' '98_76_54_32,19' is invalid using Currency.
' '98_76_54_32,19' is invalid using Float.
'
' Parsing using the Invariant culture:
' ' 987.654E-2' is invalid using Currency.
' 987.654E-2 (Float) -> 9.87654
' ' 987,654E-2' is invalid using Currency.
' ' 987,654E-2' is invalid using Float.
' (98765,43210) (Currency) -> -9.876543E+09
' '(98765,43210)' is invalid using Float.
' 9,876,543.210 (Currency) -> 9876543
' '9,876,543.210' is invalid using Float.
' '9.876.543,210' is invalid using Currency.
' '9.876.543,210' is invalid using Float.
' 98_76_54_32,19 (Currency) -> 9.876543E+09
' '98_76_54_32,19' is invalid using Float.
Poznámky
V .NET Core 3.0 a novějších verzích se hodnoty, které jsou pro reprezentaci příliš velké, zaokrouhlují na PositiveInfinity nebo NegativeInfinity podle požadavků specifikace IEEE 754. V předchozích verzích, včetně rozhraní .NET Framework, analýza hodnoty, která byla příliš velká na to, aby reprezentovala, způsobila selhání.
Parametr style
definuje prvky stylu (například prázdné znaky, oddělovače tisíců a symboly měny), které jsou povoleny v parametru s
pro úspěšné operace analýzy. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . Následující NumberStyles členové nejsou podporováni:
Parametr s
může obsahovat NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolnebo NumberFormatInfo.NaNSymbol pro jazykovou verzi určenou nástrojem provider
. V závislosti na hodnotě style
může mít také tvar:
[ws] [$] [sign][integral-digits,]integral-digits[.[ zlomkové číslice]] [E[sign]exponential-digits] [ws]
Prvky orámované v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.
Element | Popis |
---|---|
Ws | Posloupnost znaků mezer. Prázdné místo se může zobrazit na začátku, s pokud style obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, s pokud style obsahuje NumberStyles.AllowTrailingWhite příznak. |
$ | Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak. |
sign | Symbol záporného znaménka (-) nebo symbol kladného znaménka (+). Znaménko se může zobrazit na začátku, pokud příznak obsahujeNumberStyles.AllowLeadingSign, a může se zobrazit na konci, s pokud style příznak obsahujeNumberStyles.AllowTrailingSign.style s Závorky lze v s použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak. |
číslice-základu | Řada číslic od 0 do 9, které určují základní část čísla. Prvek integral-digits může chybět, pokud řetězec obsahuje prvek fractional-digits . |
, | Oddělovač skupin specifický pro jazykovou verzi. Symbol oddělovače skupin aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowThousands příznak. |
. | Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak. |
desetinné-číslice | Řada číslic od 0 do 9, které určují desetinnou část čísla. Desetinné číslice se můžou zobrazit v s , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak. |
E | Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak. |
číslice-exponentu | Řada číslic od 0 do 9, které určují exponent. |
Poznámka
Operace analýzy ignoruje všechny ukončující ZNAKY NUL (U+0000) bez s
ohledu na hodnotu argumentu style
.
Řetězec pouze s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně analyzuje, pokud je v rozsahu Single typu. Zbývající System.Globalization.NumberStyles členové řídí prvky, které mohou být přítomny, ale nemusí být přítomny, ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles příznaky ovlivňují prvky, které mohou být přítomny v nástroji s
.
Hodnota NumberStyles | Prvky povolené s kromě číslic |
---|---|
None | Pouze prvek celočíselné číslice . |
AllowDecimalPoint | Desetinná čárka (.) a desetinné číslice elementů . |
AllowExponent | Znak "e" nebo "E", který označuje exponenciální zápis. Tento příznak sám o sobě podporuje hodnoty v číslicíchformuláře Ečíslice; K úspěšné parsování řetězců s prvky, jako jsou kladné nebo záporné znaménka a symboly desetinné čárky, jsou potřeba další příznaky. |
AllowLeadingWhite | Element ws na začátku souboru s . |
AllowTrailingWhite | Element ws na konci souboru s . |
AllowLeadingSign | Element sign na začátku objektu s . |
AllowTrailingSign | Element sign na konci objektu s . |
AllowParentheses | Element sign ve formě závorek ohraničující číselnou hodnotu. |
AllowThousands | Prvek oddělovače tisíců (,). |
AllowCurrencySymbol | Prvek měny ($). |
Currency | Všechny prvky.
s Nemůže však představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu. |
Float | Element ws na začátku nebo na konci s , znaménko na začátku s a symbol desetinné čárky (.). Parametr s může také použít exponenciální notaci. |
Number | Oddělovač ws tisíců (,) a desetinná čárka (.) elementy , sign |
Any | Všechny prvky. Nemůže však s představovat šestnáctkové číslo. |
Parametr provider
je IFormatProvider implementace. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi formátu value
. Obvykle provider
se může jednat o některou z následujících možností:
Objekt CultureInfo , který představuje jazykovou verzi, která poskytuje informace o číselném formátování. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace o číselném formátování.
Objekt NumberFormatInfo , který poskytuje informace o formátování. (Jeho implementace GetFormat pouze vrátí sama sebe.)
Vlastní objekt, který implementuje IFormatProvider a používá metodu GetFormat k vytvoření instance a vrácení objektu NumberFormatInfo , který poskytuje informace o formátování.
Pokud provider
je null
, použije se NumberFormatInfo objekt pro aktuální jazykovou verzi.
Pokud s
je mimo rozsah datového Single typu, metoda vyvolá objekt OverflowException v rozhraní .NET Framework a .NET Core 2.2 a starších verzích. V .NET Core 3.0 a novějších verzích vrátí Single.NegativeInfinity , pokud s
je menší než Single.MinValue a Single.PositiveInfinity pokud s
je větší než Single.MaxValue.
Pokud je v parametru s
během operace analýzy nalezen oddělovač a příslušné oddělovače desetinných míst měny nebo čísla jsou stejné, operace parse předpokládá, že oddělovač je oddělovačem desetinných míst, nikoli oddělovačem skupin. Další informace o oddělovači najdete v tématech CurrencyDecimalSeparator, CurrencyGroupSeparatorNumberDecimalSeparator, a NumberGroupSeparator.
Viz také
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