Single.Parse Método

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

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

Parâmetros

Devoluções

Um número de ponto flutuante de precisão simples equivalente ao valor numérico ou símbolo especificado em s.

Exceções

Exemplos

O exemplo seguinte utiliza o Parse(String) método para converter um array de cadeias em valores equivalentes 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.

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

O s parâmetro pode conter o símbolo da PositiveInfinitySymbolcultura atual, NegativeInfinitySymbol, NaNSymbol ou símbolo. Esta comparação de strings é insensível a maiúsculas minúsculas no .NET Core 3.0 e versões posteriores, mas é sensível a maiúsculas minúsculas em versões anteriores, incluindo o .NET Framework. O s parâmetro pode também ser uma cadeia da forma:

[ws][sinal] [dígitos integrais[,]]dígitos integrais[.[dígitos fracionários]][dígitos exponenciais e[signo]][ws]

Os elementos entre parênteses retos ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento	Descrição
ws	Uma série de caracteres em espaços em branco.
assinar	Um símbolo de sinal negativo ou um símbolo positivo. Caracteres de signo válidos são determinados pelas NumberFormatInfo.NegativeSign propriedades e NumberFormatInfo.PositiveSign da cultura atual. Só pode ser usado um sinal de orientação.
dígitos integrais	Uma série de dígitos de 0 a 9 que especificam a parte integral do número. Sequências de dígitos integrais podem ser particionadas por um símbolo de separador de grupo. Por exemplo, em algumas culturas uma vírgula (,) separa grupos de milhares. O elemento de dígitos inteiros pode estar ausente se a cadeia contiver o elemento de dígitos fracionários .
,	Um símbolo separador de milhares específico de cultura.
.	Um símbolo de ponto decimal específico para cada cultura.
Dígitos fracionários	Uma série de dígitos de 0 a 9 que especificam a parte fracionária do número.
E	O carácter "e" ou "E", que indica que o valor é representado em notação exponencial (científica).
Dígitos exponenciais	Uma série de dígitos que variam de 0 a 9 que especificam um expoente.

O s parâmetro é interpretado usando uma combinação dos NumberStyles.Float flags e NumberStyles.AllowThousands . Isto significa que o espaço em branco e os separadores de milhares são permitidos, mas os símbolos de moeda não. Para definir explicitamente os elementos (como símbolos de moeda, separadores de milhares e espaços em branco) que podem estar presentes em s, use o Parse(String, NumberStyles) método overload.

O s parâmetro é analisado utilizando a informação de formatação num NumberFormatInfo objeto que é inicializado para a cultura do sistema atual. Para obter mais informações, veja CurrentInfo. Para analisar uma cadeia usando a informação de formatação de uma cultura específica, use o Parse(String, IFormatProvider) método ou Parse(String, NumberStyles, IFormatProvider) .

Normalmente, se passar ao Parse método uma cadeia criada ao chamar o ToString método, o valor original Single é devolvido. No entanto, devido à perda de precisão, os valores podem não ser iguais.

Se s estiver fora do alcance do tipo de dado Single, o método lança um OverflowException no .NET Framework. Em versões .NET Core 3.0 e posteriores, devolve Single.NegativeInfinity se s for menor que Single.MinValue e Single.PositiveInfinity se s for maior que Single.MaxValue.

Se um separador for encontrado no s parâmetro durante uma operação de análise sintática, e os separadores decimais e de grupo de moeda ou número aplicáveis forem os mesmos, a operação de análise analisar assume que o separador é um separador decimal e não um separador de grupo. Para mais informações sobre separadores, veja CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator, e NumberGroupSeparator.

Ver também

• ToString()
• Análise de Cadeias Numéricas em .NET

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

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

Parâmetros

Devoluções

O resultado da análise sintática utf8Text.

Implementações

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

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

Parâmetros

Devoluções

O resultado da análise sintática s.

Implementações

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

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

Parâmetros

Devoluções

Um número de ponto flutuante de precisão simples que é equivalente ao valor numérico ou símbolo especificado em s.

Exceções

Exemplos

O exemplo seguinte utiliza o Parse(String, NumberStyles) método para analisar as representações de cadeias de Single valores. O exemplo utiliza informação de formatação para a cultura 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.

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

O style parâmetro define os elementos de estilo (como espaço em branco, separadores de milhares e símbolos de moeda) que são permitidos no s parâmetro para que a operação de análise sintética tenha sucesso. Deve ser uma combinação de indicadores de bits da NumberStyles enumeração. Os seguintes NumberStyles membros não são apoiados:

• AllowHexSpecifier

• HexNumber

O s parâmetro pode conter o símbolo da PositiveInfinitySymbolcultura atual, NegativeInfinitySymbol, NaNSymbol ou símbolo. Esta comparação de strings é insensível a maiúsculas minúsculas no .NET Core 3.0 e versões posteriores, mas é sensível a maiúsculas minúsculas em versões anteriores, incluindo o .NET Framework. Dependendo do valor de style, o s parâmetro pode também assumir a forma:

[ws][$][signo][dígitos-integrais[,]]dígitos-integrais[.[dígitos fracionários]][E[signo] dígitos exponenciais][ws]

Os elementos entre parênteses retos ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

ws Uma série de caracteres em espaços em branco. O espaço em branco pode aparecer no início de s se style inclui a NumberStyles.AllowLeadingWhite bandeira, e pode aparecer no final de s se style inclui a NumberStyles.AllowTrailingWhite bandeira.

$ Um símbolo monetário específico da cultura. A sua posição na corda é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo monetário da cultura atual pode aparecer se sstyle incluir a NumberStyles.AllowCurrencySymbol bandeira.

Sinal Um símbolo de sinal negativo (-) ou um símbolo positivo (+). O sinal pode aparecer no início de s se inclui a style bandeira, e pode aparecer no final de NumberStyles.AllowLeadingSign se s inclui a styleNumberStyles.AllowTrailingSign bandeira. Parênteses podem ser usados s para indicar um valor negativo se style incluir a NumberStyles.AllowParentheses bandeira.

dígitos integrais Uma série de dígitos de 0 a 9 que especificam a parte integral do número. O elemento de dígitos inteiros pode estar ausente se a cadeia contiver o elemento de dígitos fracionários .

, Um separador de grupo específico de cultura. O símbolo separador de grupo da cultura atual pode aparecer em s se style incluir a NumberStyles.AllowThousands bandeira

. Um símbolo de ponto decimal específico para cada cultura. O símbolo de ponto decimal da cultura atual pode aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.

Dígitos fracionários Uma série de dígitos de 0 a 9 que especificam a parte fracionária do número. Dígitos fracionários podem aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.

E O carácter "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O value parâmetro pode representar um número em notação exponencial se style incluir a NumberStyles.AllowExponent bandeira.

Dígitos exponenciais Uma série de dígitos que variam de 0 a 9 que especificam um expoente.

Uma cadeia apenas com dígitos (que corresponde ao NumberStyles.None estilo) analisa sempre com sucesso se estiver no intervalo do Single tipo. Os membros restantes System.Globalization.NumberStyles controlam elementos que podem estar presentes, mas não são obrigatórios a estar presentes, na cadeia de entrada. A tabela seguinte indica como as bandeiras individuais NumberStyles afetam os elementos que podem estar presentes em s.

Valor de NumberStyles	Elementos permitidos s além dos dígitos
None	Apenas o elemento de dígitos integrais .
AllowDecimalPoint	Os elementos da vírgula decimal (.) e dos dígitos fracionários .
AllowExponent	O carácter "e" ou "E", que indica notação exponencial. Esta bandeira, por si só, suporta valores nos dígitosda formaE; São necessárias bandeiras adicionais para analisar com sucesso cadeias com elementos como sinais positivos ou negativos e símbolos de ponto decimal.
AllowLeadingWhite	O elemento ws no início de s.
AllowTrailingWhite	O elemento ws no final de s.
AllowLeadingSign	O elemento signo no início de s.
AllowTrailingSign	O elemento signo no final de s.
AllowParentheses	O elemento do signo na forma de parênteses que envolvem o valor numérico.
AllowThousands	O elemento separador dos milhares (,).
AllowCurrencySymbol	O elemento da moeda ($).
Currency	Todos os elementos. No entanto, s não pode representar um número hexadecimal ou um número em notação exponencial.
Float	O elemento ws no início ou no fim de s, sinal no início de s, e o símbolo da vírgula decimal (.). O s parâmetro também pode usar notação exponencial.
Number	Os ws, sign, milhares, o separador (,) e os elementos da vírgula decimal (.).
Any	Todos os elementos. No entanto, s não pode representar um número hexadecimal.

Alguns exemplos são s "100", "-123.456.789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" e "-Infinito".

O s parâmetro é analisado usando a informação de formatação num NumberFormatInfo objeto que é inicializado para a cultura do sistema atual. Para especificar a cultura cuja informação de formatação é usada para a operação de análise sintática, chame-se a Parse(String, NumberStyles, IFormatProvider) sobrecarga.

Normalmente, se passar ao Parse método uma cadeia criada ao chamar o ToString método, o valor original Single é devolvido. No entanto, devido à perda de precisão, os valores podem não ser iguais.

Se s estiver fora do alcance do tipo de dado Single, o método lança um OverflowException no .NET Framework. Em versões .NET Core 3.0 e posteriores, devolve Single.NegativeInfinity se s for menor que Single.MinValue e Single.PositiveInfinity se s for maior que Single.MaxValue.

Se um separador for encontrado no s parâmetro durante uma operação de análise sintática, e os separadores decimais e de grupo de moeda ou número aplicáveis forem os mesmos, a operação de análise analisar assume que o separador é um separador decimal e não um separador de grupo. Para mais informações sobre separadores, veja CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator, e NumberGroupSeparator.

Ver também

• ToString()
• TryParse
• Análise de Cadeias Numéricas em .NET

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

public:
 static float Parse(System::String ^ s, IFormatProvider ^ provider);

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

public static float Parse(string s, IFormatProvider provider);

public static float Parse(string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> single

Public Shared Function Parse (s As String, provider As IFormatProvider) As Single

Parâmetros

Devoluções

Um número de ponto flutuante de precisão simples equivalente ao valor numérico ou símbolo especificado em s.

Implementações

Exceções

Exemplos

O exemplo seguinte é o handler de eventos com clique de botão de um formulário Web. Utiliza o array devolvido pela HttpRequest.UserLanguages propriedade para determinar a localização do utilizador. De seguida, instância é um CultureInfo objeto que corresponde a esse local. O NumberFormatInfo objeto que pertence a esse CultureInfo objeto é então passado ao Parse(String, IFormatProvider) método para converter a entrada do utilizador num Single valor.

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

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

Esta sobrecarga é tipicamente usada para converter texto que pode ser formatado de várias formas para um Single valor. Por exemplo, pode ser usado para converter o texto introduzido por um utilizador numa caixa de texto HTML para um valor numérico.

O s parâmetro é interpretado usando uma combinação dos NumberStyles.Float flags e NumberStyles.AllowThousands . O s parâmetro pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbol, ou NumberFormatInfo.NaNSymbol símbolo para a cultura especificada por provider. Esta comparação de strings é insensível a maiúsculas minúsculas no .NET Core 3.0 e versões posteriores, mas é sensível a maiúsculas minúsculas em versões anteriores, incluindo o .NET Framework. O s parâmetro pode conter uma cadeia da forma:

[ws][sinal]dígitos integrais[.[dígitos fracionários]][E[signo] dígitos exponenciais][ws]

Os elementos opcionais estão enquadrados entre colchetes quadrados ([ e ]). Os elementos que contêm o termo "dígitos" consistem numa série de caracteres numéricos que variam de 0 a 9.

Elemento	Descrição
ws	Uma série de caracteres em espaços em branco.
assinar	Um símbolo de sinal negativo (-) ou um símbolo positivo (+).
dígitos integrais	Uma série de dígitos de 0 a 9 que especificam a parte integral do número. Sequências de dígitos integrais podem ser particionadas por um símbolo de separador de grupo. Por exemplo, em algumas culturas uma vírgula (,) separa grupos de milhares. O elemento de dígitos inteiros pode estar ausente se a cadeia contiver o elemento de dígitos fracionários .
.	Um símbolo de ponto decimal específico para cada cultura.
Dígitos fracionários	Uma série de dígitos de 0 a 9 que especificam a parte fracionária do número.
E	O carácter "e" ou "E", que indica que o valor é representado em notação exponencial (científica).
Dígitos exponenciais	Uma série de dígitos que variam de 0 a 9 que especificam um expoente.

Para mais informações sobre formatos numéricos, consulte o tópico Tipos de Formatação .

O provider parâmetro é uma IFormatProvider implementação cujo GetFormat método devolve um NumberFormatInfo objeto que fornece informação de formatação específica para a cultura. Quando o Parse(String, IFormatProvider) método é invocado, chama o provider método do GetFormat parâmetro e passa-lhe um Type objeto que representa o NumberFormatInfo tipo. O GetFormat método devolve então o NumberFormatInfo objeto que fornece informação sobre o formato do s parâmetro. Existem três formas de usar o provider parâmetro para fornecer informação de formatação personalizada à operação de análise sintática:

• Pode passar um CultureInfo objeto que representa a cultura que fornece a informação de formatação. O seu GetFormat método devolve o NumberFormatInfo objeto que fornece informação numérica de formatação para essa cultura.

• Pode passar o objeto real NumberFormatInfo que fornece a informação numérica de formatação. (A sua implementação de GetFormat simplesmente devolve-se a si própria.)

• Podes passar um objeto personalizado que implementa IFormatProvider. O seu GetFormat método instancia e devolve o NumberFormatInfo objeto que fornece a informação de formatação.

Se provider for null ou a NumberFormatInfo não puder ser obtida, utiliza-se a informação de formatação para a cultura do sistema atual.

Se s estiver fora do alcance do tipo de dado Single, o método lança um OverflowException no .NET Framework. Em versões .NET Core 3.0 e posteriores, devolve Single.NegativeInfinity se s for menor que Single.MinValue e Single.PositiveInfinity se s for maior que Single.MaxValue.

Se um separador for encontrado no s parâmetro durante uma operação de análise sintática, e os separadores decimais e de grupo de moeda ou número aplicáveis forem os mesmos, a operação de análise analisar assume que o separador é um separador decimal e não um separador de grupo. Para mais informações sobre separadores, veja CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator, e NumberGroupSeparator.

Alguns exemplos são s "100", "-123.456.789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" e "-Infinito".

Ver também

• ToString()
• TryParse
• Análise de Cadeias Numéricas em .NET

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

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

Parâmetros

Devoluções

O resultado da análise sintática utf8Text.

Implementações

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

public static float Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);

public static float Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> single

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, Optional provider As IFormatProvider = Nothing) As Single

Parâmetros

Devoluções

Um número de ponto flutuante de precisão simples que é equivalente ao valor numérico ou símbolo especificado em s.

Implementações

Exceções

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

Se s estiver fora do alcance do Single tipo de dados, o método devolve Single.NegativeInfinity se s for menor que Single.MinValue e Single.PositiveInfinity se s for maior que Single.MaxValue.

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

Origem:

Single.cs

public:
 static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);

public:
 static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<float>::Parse;

public static float Parse(string s, System.Globalization.NumberStyles style, IFormatProvider provider);

public static float Parse(string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> single

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Single

Parâmetros

Devoluções

Um número de ponto flutuante de precisão simples equivalente ao valor numérico ou símbolo especificado em s.

Implementações

Exceções

Exemplos

O exemplo de código seguinte utiliza o Parse(String, NumberStyles, IFormatProvider) método para analisar as representações de cadeias de Single valores. Cada string num array é analisada usando as convenções de formatação do en-US, nl-NL, e uma cultura personalizada. A cultura personalizada define o seu símbolo separador de grupo como o sublinhado ("_") e o tamanho do grupo como dois.

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.

Observações

No .NET Core 3.0 e posteriores, valores demasiado grandes para serem representados são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo o .NET Framework, analisar um valor demasiado grande para ser representado resultava em falha.

O style parâmetro define os elementos de estilo (como espaço em branco, separadores de milhares e símbolos de moeda) que são permitidos no s parâmetro para que a operação de análise sintética tenha sucesso. Deve ser uma combinação de indicadores de bits da NumberStyles enumeração. Os seguintes NumberStyles membros não são apoiados:

• AllowHexSpecifier

• HexNumber

O s parâmetro pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbol, ou NumberFormatInfo.NaNSymbol símbolo para a cultura especificada por provider. Esta comparação de strings é insensível a maiúsculas minúsculas no .NET Core 3.0 e versões posteriores, mas é sensível a maiúsculas minúsculas em versões anteriores, incluindo o .NET Framework. Dependendo do valor de style, o s parâmetro pode também assumir a forma:

[ws] [$] [signo][dígitos integrais,]dígitos integrais[.[ dígitos fracionários]][E[signo] dígitos exponenciais][ws]

Elementos enquadrados entre colchetes quadrados ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento	Descrição
ws	Uma série de caracteres em espaços em branco. O espaço em branco pode aparecer no início de s se style inclui a NumberStyles.AllowLeadingWhite bandeira, e pode aparecer no final de s se style inclui a NumberStyles.AllowTrailingWhite bandeira.
$	Um símbolo monetário específico de cada cultura. A sua posição na corda é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo monetário da cultura atual pode aparecer se sstyle incluir a NumberStyles.AllowCurrencySymbol bandeira.
assinar	Um símbolo de sinal negativo (-) ou um símbolo positivo (+). O sinal pode aparecer no início de s se inclui a style bandeira, e pode aparecer no final de NumberStyles.AllowLeadingSign se s inclui a styleNumberStyles.AllowTrailingSign bandeira. Parênteses podem ser usados s para indicar um valor negativo se style incluir a NumberStyles.AllowParentheses bandeira.
dígitos integrais	Uma série de dígitos de 0 a 9 que especificam a parte integral do número. O elemento de dígitos inteiros pode estar ausente se a cadeia contiver o elemento de dígitos fracionários .
,	Um separador de grupo específico de cultura. O símbolo separador de grupo da cultura atual pode aparecer em s se style incluir a NumberStyles.AllowThousands bandeira
.	Um símbolo de ponto decimal específico para cada cultura. O símbolo de ponto decimal da cultura atual pode aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.
Dígitos fracionários	Uma série de dígitos de 0 a 9 que especificam a parte fracionária do número. Dígitos fracionários podem aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.
E	O carácter "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O s parâmetro pode representar um número em notação exponencial se style incluir a NumberStyles.AllowExponent bandeira.
Dígitos exponenciais	Uma série de dígitos que variam de 0 a 9 que especificam um expoente.

Uma cadeia apenas com dígitos (que corresponde ao NumberStyles.None estilo) analisa sempre com sucesso se estiver no intervalo do Single tipo. Os membros restantes System.Globalization.NumberStyles controlam elementos que podem estar presentes, mas não são obrigatórios a estar presentes, na cadeia de entrada. A tabela seguinte indica como as bandeiras individuais NumberStyles afetam os elementos que podem estar presentes em s.

Valor de NumberStyles	Elementos permitidos s além dos dígitos
None	Apenas o elemento de dígitos integrais .
AllowDecimalPoint	Os elementos da vírgula decimal (.) e dos dígitos fracionários .
AllowExponent	O carácter "e" ou "E", que indica notação exponencial. Esta bandeira, por si só, suporta valores nos dígitosda formaE; São necessárias bandeiras adicionais para analisar com sucesso cadeias com elementos como sinais positivos ou negativos e símbolos de ponto decimal.
AllowLeadingWhite	O elemento ws no início de s.
AllowTrailingWhite	O elemento ws no final de s.
AllowLeadingSign	O elemento signo no início de s.
AllowTrailingSign	O elemento signo no final de s.
AllowParentheses	O elemento do signo na forma de parênteses que envolvem o valor numérico.
AllowThousands	O elemento separador dos milhares (,).
AllowCurrencySymbol	O elemento da moeda ($).
Currency	Todos os elementos. No entanto, s não pode representar um número hexadecimal ou um número em notação exponencial.
Float	O elemento ws no início ou no fim de s, sinal no início de s, e o símbolo da vírgula decimal (.). O s parâmetro também pode usar notação exponencial.
Number	Os ws, sign, milhares, o separador (,) e os elementos da vírgula decimal (.).
Any	Todos os elementos. No entanto, s não pode representar um número hexadecimal.

O provider parâmetro é uma IFormatProvider implementação. O seu GetFormat método devolve um NumberFormatInfo objeto que fornece informação específica da cultura sobre o formato de value. Normalmente, provider pode ser qualquer um dos seguintes:

• Um CultureInfo objeto que representa a cultura que fornece informação numérica de formatação. O seu GetFormat método devolve o NumberFormatInfo objeto que fornece a informação numérica de formatação.

• Um NumberFormatInfo objeto que fornece informação de formatação. (A sua implementação de GetFormat simplesmente devolve-se a si própria.)

• Um objeto personalizado que implementa IFormatProvider e utiliza o GetFormat método para instanciar e devolver o NumberFormatInfo objeto que fornece informação de formatação.

Se provider for null, o NumberFormatInfo objeto para a cultura atual é usado.

Se s estiver fora do alcance do tipo de dado Single, o método lança um OverflowException no .NET Framework. Em versões .NET Core 3.0 e posteriores, devolve Single.NegativeInfinity se s for menor que Single.MinValue e Single.PositiveInfinity se s for maior que Single.MaxValue.

Se um separador for encontrado no s parâmetro durante uma operação de análise sintática, e os separadores decimais e de grupo de moeda ou número aplicáveis forem os mesmos, a operação de análise analisar assume que o separador é um separador decimal e não um separador de grupo. Para mais informações sobre separadores, veja CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator, e NumberGroupSeparator.

Ver também

• ToString()
• Análise de Cadeias Numéricas em .NET