Single.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Převede řetězcovou reprezentaci čísla na ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou přesností.

Přetížení

Parse(String)	Převede řetězcovou reprezentaci čísla na ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou přesností.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou přesností.
Parse(String, IFormatProvider)	Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou přesností.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	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 jednoduchou 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 ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou přesností.

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

Parse(String)

Zdroj:

Single.cs

Převede řetězcovou reprezentaci čísla na ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou přesností.

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

Návraty

Single

Jednopřesné číslo s plovoucí desetinnou čárkou odpovídající číselné hodnotě nebo symbolu zadanému v s.

Výjimky

ArgumentNullException

s je null.

FormatException

s nepředstavuje číslo v platném formátu.

OverflowException

Pouze .NET Framework a .NET Core 2.2 a starší verze: 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í hodnoty Single.

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

Parametr s může obsahovat PositiveInfinitySymbolaktuální jazykové verze, NegativeInfinitySymbol, NaNSymbolnebo řetězec formuláře:

[ws] [znaménko] [celočíselné číslice[,]]celočíselné číslice[.[desetinné číslice]][e[znaménko]exponenciální číslice][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ů.
znaménko	Symbol záporného znaménka nebo symbol kladného znaménka Platné znaky znaménka jsou určeny NumberFormatInfo.NegativeSign a NumberFormatInfo.PositiveSign vlastnostmi aktuální jazykové verze. Lze použít pouze úvodní znaménko.
celočíselné číslice	Řada číslic v rozsahu od 0 do 9, která určuje celočíselnou část čísla. Spuštění integrálních číslic lze rozdělit pomocí symbolu oddělovače skupin. Například v některých kulturách čárka (,) odděluje skupiny tisíců. celočíselné číslice prvek může chybět, pokud řetězec obsahuje desetinné číslice prvek.
,	Symbol oddělovače tisíců specifických pro jazykovou verzi.
.	Symbol desetinné čárky specifické pro jazykovou verzi.
desetinné číslice	Řada číslic v rozsahu od 0 do 9, která určuje desetinnou část čísla.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem.
exponenciální číslice	Řada číslic v rozsahu od 0 do 9, která určuje exponent.

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 Parse(String, NumberStyles).

Parametr s je analyzován pomocí informací o formátování v objektu NumberFormatInfo, který je inicializován pro aktuální systémovou jazykovou verzi. Další informace najdete v tématu CurrentInfo. K analýze řetězce pomocí informací o formátování konkrétní jazykové verze použijte Parse(String, IFormatProvider) nebo Parse(String, NumberStyles, IFormatProvider) metodu.

Obvykle platí, že pokud předáte Parse metodě řetězec vytvořený voláním metody ToString, vrátí se původní hodnota Single. Kvůli ztrátě přesnosti se však hodnoty nemusí shodovat.

Pokud je s mimo rozsah datového typu Single, vyvolá metoda 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 je s menší než Single.MinValue a Single.PositiveInfinity, pokud je s větší než Single.MaxValue.

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

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Zdroj:

Single.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

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

provider

IFormatProvider

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

Návraty

Single

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:

Single.cs

Parsuje rozsah znaků do hodnoty.

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 o s.

Návraty

Single

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(String, NumberStyles)

Zdroj:

Single.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu na ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou 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, které se má převést.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Float v kombinaci s AllowThousands.

Návraty

Single

Jednopřesné číslo s plovoucí desetinnou čárkou, které odpovídá číselné hodnotě nebo symbolu zadanému v s.

Výjimky

ArgumentNullException

s je null.

FormatException

s není číslo v platném formátu.

OverflowException

Pouze .NET Framework a .NET Core 2.2 a starší verze: s představuje číslo, které je menší než Single.MinValue nebo větší než Single.MaxValue.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style obsahuje hodnotu AllowHexSpecifier.

Příklady

Následující příklad používá metodu Parse(String, NumberStyles) k analýze řetězcových reprezentací Single 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 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í.

Parametr style definuje prvky stylu (například prázdné znaky, oddělovače tisíců a symboly měny), které jsou povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu. Následující NumberStyles členy nejsou podporovány:

• AllowHexSpecifier

• HexNumber

Parametr s může obsahovat PositiveInfinitySymbolaktuální jazykové verze , NegativeInfinitySymbol, NaNSymbol. V závislosti na hodnotě stylemůže mít také tvar:

[ws] [$] [znaménko] [celočíselné číslice[,]]celočíselné číslice[.[desetinné číslice]][E[znaménko ]exponenciální číslice][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é znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a 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 a NumberFormatInfo.CurrencyPositivePattern vlastnosti aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.

znaménko symbol záporného znaménka (-) nebo symbol kladného znaménka (+). 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 řady číslic v rozsahu od 0 do 9, které určují integrální část čísla. celočíselné číslice prvek může chybět, pokud řetězec obsahuje desetinné číslice prvek.

, 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 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 řady číslic v rozsahu od 0 do 9, které určují 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 hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr value může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.

exponenciální číslice řady číslic v rozsahu od 0 do 9, které určují 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 Single. Zbývající System.Globalization.NumberStyles členy ovládací prvky, které mohou být přítomny, ale nejsou nutné, aby byly 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	Desetinná čárka (.) a desetinné číslice prvky.
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis. Tento příznak sám podporuje hodnoty ve formuláři čísliceEčíslice; Další příznaky jsou potřeba k úspěšnému parsování řetězců 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	Element oddělovače tisíců (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. s však nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo konci s, znaménko na začátku sa symbol desetinné čárky (.). 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 prvky. s však nemůže 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 inicializovaném pro aktuální jazykovou verzi systému. Chcete-li určit jazykovou verzi, jejíž informace formátování se používají pro operaci analýzy, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.

Obvykle platí, že pokud předáte Parse metodě řetězec vytvořený voláním metody ToString, vrátí se původní hodnota Single. Kvůli ztrátě přesnosti se však hodnoty nemusí shodovat.

Pokud je s mimo rozsah datového typu Single, vyvolá metoda 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 je s menší než Single.MinValue a Single.PositiveInfinity, pokud je s větší než Single.MaxValue.

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()
• TryParse
• analýza číselných řetězců v rozhraní .NET

Parse(String, IFormatProvider)

Zdroj:

Single.cs

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s jednoduchou přesností.

public:
 static float Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<float>::Parse;

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

provider

IFormatProvider

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

Návraty

Single

Jednopřesné číslo s plovoucí desetinnou čárkou odpovídající číselné hodnotě nebo symbolu zadanému v s.

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

FormatException

s nepředstavuje číslo v platném formátu.

OverflowException

Pouze .NET Framework a .NET Core 2.2 a starší verze: s představuje číslo menší než Single.MinValue nebo větší než Single.MaxValue.

Příklady

Následující příklad je obslužná rutina události kliknutí na tlačítko webového formuláře. Používá pole vrácené vlastností HttpRequest.UserLanguages k určení národního prostředí uživatele. Potom vytvoří instanci CultureInfo objektu, který odpovídá danému národnímu prostředí. Objekt NumberFormatInfo, který patří do objektu CultureInfo, se pak předá metodě Parse(String, IFormatProvider), která převede vstup uživatele na hodnotu Single.

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 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 obvykle používá k převodu textu, který lze formátovat různými způsoby na Single hodnotu. Dá se například použít k převodu textu zadaného uživatelem do textového pole HTML na číselnou hodnotu.

Parametr s se interpretuje pomocí kombinace příznaků NumberStyles.Float a NumberStyles.AllowThousands. Parametr s může obsahovat NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolnebo NumberFormatInfo.NaNSymbol pro jazykovou verzi určenou providernebo může obsahovat řetězec formuláře:

[ws] [znaménko]celočíselné číslice[.[desetinné číslice]][E[znaménko]exponenciální číslice][ws]

Volitelné prvky jsou rámovány v hranatých závorkách ([ a ]). Prvky obsahující termín "číslice" se skládají z řady číselných znaků v rozsahu od 0 do 9.

Element	Popis
ws	Řada prázdných znaků.
znaménko	Symbol záporného znaménka (-) nebo symbol kladného znaménka (+).
celočíselné číslice	Řada číslic v rozsahu od 0 do 9, která určuje celočíselnou část čísla. Spuštění integrálních číslic lze rozdělit pomocí symbolu oddělovače skupin. Například v některých kulturách čárka (,) odděluje skupiny tisíců. celočíselné číslice prvek může chybět, pokud řetězec obsahuje desetinné číslice prvek.
.	Symbol desetinné čárky specifické pro jazykovou verzi.
desetinné číslice	Řada číslic v rozsahu od 0 do 9, která určuje desetinnou část čísla.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem.
exponenciální číslice	Řada číslic v rozsahu od 0 do 9, která určuje exponent.

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

Parametr provider je IFormatProvider implementace, jejíž metoda GetFormat vrací objekt NumberFormatInfo, který poskytuje informace o formátování specifické pro jazykovou verzi. Když je vyvolána Parse(String, IFormatProvider) metoda, volá provider parametr GetFormat metodu a předá ho Type objekt, který představuje typ NumberFormatInfo. Metoda GetFormat pak vrátí objekt NumberFormatInfo, který poskytuje informace o formátu s parametru. Existují tři způsoby použití parametru provider k zadání vlastních informací o formátování do operace analýzy:

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

• Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o číselném formátování. (Její implementace GetFormat se vrátí sama.)

• Můžete předat vlastní objekt, který implementuje IFormatProvider. Jeho GetFormat metoda vytvoří instanci a vrátí objekt NumberFormatInfo, který poskytuje informace o formátování.

Pokud je providernull nebo NumberFormatInfo nelze získat, použijí se informace o formátování aktuální jazykové verze systému.

Pokud je s mimo rozsah datového typu Single, vyvolá metoda 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 je s menší než Single.MinValue a Single.PositiveInfinity, pokud je s větší než Single.MaxValue.

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.

Mezi příklady s patří "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3,1416", "600", "-.123" a "-Infinity".

Viz také

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

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Zdroj:

Single.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

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

Návraty

Single

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:

Single.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 jednoduchou přesností.

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ů, který obsahuje číslo, které chcete 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 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.

Návraty

Single

Jednopřesné číslo s plovoucí desetinnou čárkou, které odpovídá číselné hodnotě nebo symbolu zadanému v s.

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Výjimky

FormatException

s nepředstavuje číselnou hodnotu.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style je hodnota AllowHexSpecifier.

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

Pokud je s mimo rozsah datového typu Single, vrátí metoda Single.NegativeInfinity, pokud je s menší než Single.MinValue a Single.PositiveInfinity, pokud je s větší než Single.MaxValue.

Parse(String, NumberStyles, IFormatProvider)

Zdroj:

Single.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 jednoduchou přesností.

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);

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

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v 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.

Návraty

Single

Jednopřesné číslo s plovoucí desetinnou čárkou odpovídající číselné hodnotě nebo symbolu zadanému v s.

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

FormatException

s nepředstavuje číselnou hodnotu.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style je hodnota AllowHexSpecifier.

OverflowException

Pouze .NET Framework a .NET Core 2.2 a starší verze: 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-NLa vlastní jazykové verze. Vlastní jazyková verze definuje symbol oddělovače skupin jako podtržítko (_) a jeho 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 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í.

Parametr style definuje prvky stylu (například prázdné znaky, oddělovače tisíců a symboly měny), které jsou povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu. Následující NumberStyles členy nejsou podporovány:

• AllowHexSpecifier

• HexNumber

Parametr s může obsahovat NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolnebo NumberFormatInfo.NaNSymbol pro jazykovou verzi určenou provider. V závislosti na hodnotě stylemůže mít také tvar:

[ws] [$] [znaménko] [celočíselné číslice,]celočíselné číslice[.[desetinné číslice]][E[znaménko]exponenciální číslice][ws]

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

Element	Popis
ws	Řada prázdných znaků. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a 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 a NumberFormatInfo.CurrencyPositivePattern vlastnosti aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko	Symbol záporného znaménka (-) nebo symbol kladného znaménka (+). 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. celočíselné číslice prvek může chybět, pokud řetězec obsahuje desetinné číslice prvek.
,	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 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 hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style 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 Single. Zbývající System.Globalization.NumberStyles členy ovládací prvky, které mohou být přítomny, ale nejsou nutné, aby byly 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	Desetinná čárka (.) a desetinné číslice prvky.
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis. Tento příznak sám podporuje hodnoty ve formuláři čísliceEčíslice; Další příznaky jsou potřeba k úspěšnému parsování řetězců 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	Element oddělovače tisíců (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. s však nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo konci s, znaménko na začátku sa symbol desetinné čárky (.). 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 prvky. s však nemůže představovat šestnáctkové číslo.

Parametr provider je IFormatProvider implementace. Jeho GetFormat metoda vrátí objekt NumberFormatInfo, který poskytuje informace specifické pro jazykovou verzi o formátu value. Obvykle provider může být libovolná 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í objekt NumberFormatInfo, který poskytuje informace o číselném formátování.

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

• 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 je providernull, použije se objekt NumberFormatInfo pro aktuální jazykovou verzi.

Pokud je s mimo rozsah datového typu Single, vyvolá metoda 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 je s menší než Single.MinValue a Single.PositiveInfinity, pokud je s větší než Single.MaxValue.

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