Single.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

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

Přetížení

Name	Description
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é, aby představovaly, se zaokrouhlují na PositiveInfinity specifikaci IEEE 754 nebo NegativeInfinity podle potřeby. 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

Číslo s plovoucí desetinnou čárkou s jednoduchou přesností 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í 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 se hodnoty, které jsou příliš velké, aby představovaly, se zaokrouhlují na PositiveInfinity specifikaci IEEE 754 nebo NegativeInfinity podle potřeby. 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 aktuální jazykovou PositiveInfinitySymbolverzi , NegativeInfinitySymbolnebo NaNSymbol symbol. Toto porovnání řetězců nerozlišuje malá a velká písmena v .NET Core 3.0 a novějších verzích, ale v předchozích verzích, včetně rozhraní .NET Framework, rozlišují malá a velká písmena. Parametrem s může být také řetězec formuláře:

[ws][znaménko] [integrální číslice[,]]celočíselné číslice[.[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ů.
znaménko	Symbol záporného znaménka nebo symbol kladného znaménka Platné znaky znaménka jsou určeny vlastnostmi NumberFormatInfo.NegativeSignNumberFormatInfo.PositiveSign aktuální jazykové verze. Lze použít pouze úvodní znaménko.
integrální číslice	Řada číslic v rozsahu od 0 do 9, která určuje celočíselnou část čísla. Spuštění integrálních číslic je možné 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 NumberStyles.Float příznaků a NumberStyles.AllowThousands příznaků. 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řítomny , spoužijte Parse(String, NumberStyles) přetížení metody.

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 na webu CurrentInfo. K analýze řetězce pomocí informací o formátování konkrétní jazykové verze použijte metodu nebo Parse(String, NumberStyles, IFormatProvider) metoduParse(String, IFormatProvider).

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

Pokud s je mimo rozsah datového Single typu, metoda vyvolá rozhraní OverflowException .NET Framework a .NET Core 2.2 a starší verze. 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 zjištěn oddělovač a platné oddělovače měny nebo čísla desetinných míst a oddělovače skupin jsou stejné, operace analýzy předpokládá, že oddělovač je oddělovač desetinných míst, nikoli oddělovač skupin. Další informace o oddělovači naleznete v tématu CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatora NumberGroupSeparator.

Viz také

• ToString()
• Analýza číselných řetězců v .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 utf8Textformátování specifické pro jazykovou verzi .

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 sformátování specifické pro jazykovou verzi .

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, kterou je třeba zadat, se zkombinuje Float 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 menší než Single.MinValue nebo větší než Single.MaxValue.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style AllowHexSpecifier obsahuje hodnotu.

Příklady

Následující příklad používá metodu Parse(String, NumberStyles) k analýze řetězcové Single reprezentace 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é, aby představovaly, se zaokrouhlují na PositiveInfinity specifikaci IEEE 754 nebo NegativeInfinity podle potřeby. 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 v parametru s povolené, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . Následující NumberStyles členové nejsou podporováni:

• AllowHexSpecifier

• HexNumber

Parametr s může obsahovat aktuální jazykovou PositiveInfinitySymbolverzi , NegativeInfinitySymbolnebo NaNSymbol symbol. Toto porovnání řetězců nerozlišuje malá a velká písmena v .NET Core 3.0 a novějších verzích, ale v předchozích verzích, včetně rozhraní .NET Framework, rozlišují malá a velká písmena. V závislosti na hodnotě styleparametru s může mít také podobu:

[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é znaky se můžou objevit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingWhite , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.

$ Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePatternNumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s případě, že style obsahuje NumberStyles.AllowCurrencySymbol příznak.

Znamení Symbol záporného znaménka (-) nebo symbol kladného znaménka (+). Znaménko se může zobrazit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.

integrální čí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, s pokud style příznak obsahuje NumberStyles.AllowThousands .

. Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit, s pokud style příznak obsahuje NumberStyles.AllowDecimalPoint .

desetinné číslice Řada číslic v rozsahu od 0 do 9, která určuje desetinnou část čísla. Desetinná číslice se můžou zobrazit, s pokud style příznak NumberStyles.AllowDecimalPoint obsahuje.

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ápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.

exponenciální číslice Řada číslic v rozsahu od 0 do 9, která určuje exponent.

Poznámka

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

Řetězec s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje, pokud je v rozsahu Single typu. 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é NumberStyles příznaky ovlivňují prvky, které mohou být přítomny v s.

Hodnota NumberStyles	Prvky povolené s kromě číslic
None	Pouze celočíselný prvek číslic.
AllowDecimalPoint	Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis. Tento příznak sám podporuje hodnoty v číslicíchformuláře Ečí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	Element ws na začátku s.
AllowTrailingWhite	Prvek ws na konci .s
AllowLeadingSign	Prvek znaménka na začátku s.
AllowTrailingSign	Prvek znaménka na konci znaku s.
AllowParentheses	Prvek znaménka 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 Nelze však reprezentovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo na konci sznaku , na začátku znaku sa symbol desetinné čárky (.). Parametr s může také použít exponenciální zápis.
Number	Elementy ws, signoddělovač tisíců (,) a desetinná čárka (.).
Any	Všechny prvky. s Nelze však reprezentovat š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 je analyzován pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální systémovou jazykovou verzi. 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 metodu Parse řetězec vytvořený voláním ToString metody, vrátí se původní Single hodnota. Kvůli ztrátě přesnosti se však hodnoty nemusí shodovat.

Pokud s je mimo rozsah datového Single typu, metoda vyvolá rozhraní OverflowException .NET Framework a .NET Core 2.2 a starší verze. 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 zjištěn oddělovač a platné oddělovače měny nebo čísla desetinných míst a oddělovače skupin jsou stejné, operace analýzy předpokládá, že oddělovač je oddělovač desetinných míst, nikoli oddělovač skupin. Další informace o oddělovači naleznete v tématu CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatora NumberGroupSeparator.

Viz také

• ToString()
• TryParse
• Analýza číselných řetězců v .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 sformátování specifické pro jazykovou verzi .

Návraty

Single

Číslo s plovoucí desetinnou čárkou s jednoduchou přesností 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é 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ří do daného CultureInfo objektu Parse(String, IFormatProvider) , se pak předá metodě pro převod vstupu 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 se hodnoty, které jsou příliš velké, aby představovaly, se zaokrouhlují na PositiveInfinity specifikaci IEEE 754 nebo NegativeInfinity podle potřeby. 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 naformá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 NumberStyles.Float příznaků a NumberStyles.AllowThousands příznaků. Parametr s může obsahovat NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolnebo NumberFormatInfo.NaNSymbol symbol pro jazykovou verzi určenou .provider Toto porovnání řetězců nerozlišuje malá a velká písmena v .NET Core 3.0 a novějších verzích, ale v předchozích verzích, včetně rozhraní .NET Framework, rozlišují malá a velká písmena. Parametr s může obsahovat řetězec formuláře:

[ws][znaménko]celočíselné číslice[.[desetinné číslice]][E[sign]exponential-digits][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 (+).
integrální číslice	Řada číslic v rozsahu od 0 do 9, která určuje celočíselnou část čísla. Spuštění integrálních číslic je možné 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 naleznete 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. Parse(String, IFormatProvider) Při vyvolání metody volá metodu provider parametru GetFormat 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 použití parametru provider k zadání vlastních informací o formátování do operace analýzy:

• 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 číselné formátování informace pro danou jazykovou verzi.

• Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o číselném formátování. (Její 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í aktuální jazykové verze systému.

Pokud s je mimo rozsah datového Single typu, metoda vyvolá rozhraní OverflowException .NET Framework a .NET Core 2.2 a starší verze. 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 zjištěn oddělovač a platné oddělovače měny nebo čísla desetinných míst a oddělovače skupin jsou stejné, operace analýzy předpokládá, že oddělovač je oddělovač desetinných míst, nikoli oddělovač skupin. Další informace o oddělovači naleznete v tématu CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatora NumberGroupSeparator.

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 .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 utf8Textformátování specifické pro jazykovou verzi .

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, kterou je třeba zadat, se zkombinuje Float s AllowThousands.

provider

IFormatProvider

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

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 AllowHexSpecifier je hodnota.

Poznámky

V .NET Core 3.0 a novějších se hodnoty, které jsou příliš velké, aby představovaly, se zaokrouhlují na PositiveInfinity specifikaci IEEE 754 nebo NegativeInfinity podle potřeby. 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 s je mimo rozsah datového Single typu, metoda vrátí Single.NegativeInfinity , pokud s je menší než Single.MinValue a Single.PositiveInfinity pokud s je 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, kterou je třeba zadat, se zkombinuje Float s AllowThousands.

provider

IFormatProvider

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

Návraty

Single

Číslo s plovoucí desetinnou čárkou s jednoduchou přesností 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 AllowHexSpecifier je hodnota.

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 kódu používá metodu Parse(String, NumberStyles, IFormatProvider) k analýze řetězcové Single reprezentace 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é, aby představovaly, se zaokrouhlují na PositiveInfinity specifikaci IEEE 754 nebo NegativeInfinity podle potřeby. 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 v parametru s povolené, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . Následující NumberStyles členové nejsou podporováni:

• AllowHexSpecifier

• HexNumber

Parametr s může obsahovat NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolnebo NumberFormatInfo.NaNSymbol symbol pro jazykovou verzi určenou .provider Toto porovnání řetězců nerozlišuje malá a velká písmena v .NET Core 3.0 a novějších verzích, ale v předchozích verzích, včetně rozhraní .NET Framework, rozlišují malá a velká písmena. V závislosti na hodnotě styleparametru s může mít také podobu:

[ws] [] [$sign][integral-digits,]integral-digits[.[ zlomkové číslice]][E[sign]exponential-digits][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 příznak obsahuje NumberStyles.AllowLeadingWhite , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePatternNumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s případě, že style obsahuje NumberStyles.AllowCurrencySymbol příznak.
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 příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
integrální čí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, s pokud style příznak obsahuje NumberStyles.AllowThousands .
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit, s pokud style příznak obsahuje NumberStyles.AllowDecimalPoint .
desetinné číslice	Řada číslic v rozsahu od 0 do 9, která určuje desetinnou část čísla. Desetinná číslice se můžou zobrazit, s pokud style příznak NumberStyles.AllowDecimalPoint obsahuje.
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ápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.
exponenciální číslice	Řada číslic v rozsahu od 0 do 9, která určuje exponent.

Poznámka

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

Řetězec s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje, pokud je v rozsahu Single typu. 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é NumberStyles příznaky ovlivňují prvky, které mohou být přítomny v s.

Hodnota NumberStyles	Prvky povolené s kromě číslic
None	Pouze celočíselný prvek číslic.
AllowDecimalPoint	Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent	Znak "e" nebo "E", který označuje exponenciální zápis. Tento příznak sám podporuje hodnoty v číslicíchformuláře Ečí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	Element ws na začátku s.
AllowTrailingWhite	Prvek ws na konci .s
AllowLeadingSign	Prvek znaménka na začátku s.
AllowTrailingSign	Prvek znaménka na konci znaku s.
AllowParentheses	Prvek znaménka 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 Nelze však reprezentovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo na konci sznaku , na začátku znaku sa symbol desetinné čárky (.). Parametr s může také použít exponenciální zápis.
Number	Elementy ws, signoddělovač tisíců (,) a desetinná čárka (.).
Any	Všechny prvky. s Nelze však reprezentovat šestnáctkové číslo.

Parametr provider je IFormatProvider implementace. Jeho GetFormat metoda vrátí NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi o formátu value. provider Obvykle se může jednat o jednu 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í. (Její 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 ano null, NumberFormatInfo použije se objekt pro aktuální jazykovou verzi.

Pokud s je mimo rozsah datového Single typu, metoda vyvolá rozhraní OverflowException .NET Framework a .NET Core 2.2 a starší verze. 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 zjištěn oddělovač a platné oddělovače měny nebo čísla desetinných míst a oddělovače skupin jsou stejné, operace analýzy předpokládá, že oddělovač je oddělovač desetinných míst, nikoli oddělovač skupin. Další informace o oddělovači naleznete v tématu CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatora NumberGroupSeparator.

Viz také

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