Compartilhar via

Single.Parse Método

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Converte a representação de cadeia de caracteres de um número em seu número de ponto flutuante de precisão única equivalente.

Sobrecargas

Parse(String)

Converte a representação de cadeia de caracteres de um número em seu número de ponto flutuante de precisão única equivalente.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analisa um intervalo de caracteres em um valor.
Parse(String, NumberStyles)

Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu número de ponto flutuante de precisão única equivalente.
Parse(String, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato específico à cultura especificado em seu número de ponto flutuante de precisão única equivalente.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte um intervalo de caracteres que contém a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu número de ponto flutuante de precisão única equivalente.
Parse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu número de ponto flutuante de precisão única equivalente.

Comentários

No .NET Core 3.0 e posterior, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação do IEEE 754. Em versões anteriores, incluindo o .NET Framework, a análise de um valor muito grande para representar resultou em falha.

Parse(String)

Origem:
Single.cs
Origem:
Single.cs
Origem:
Single.cs

Converte a representação de cadeia de caracteres de um número em seu número de ponto flutuante de precisão única equivalente.

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

s
String

Uma cadeia de caracteres que contém um número a ser convertido.

Retornos

Single

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

Exceções

ArgumentNullException

s é null.

FormatException

s não representa um número em um formato válido.

OverflowException

Somente .NET Framework e .NET Core 2.2 e versões anteriores: s representa um número menor que Single.MinValue ou maior que Single.MaxValue.

Exemplos

O exemplo a seguir usa o método Parse(String) para converter uma matriz de cadeias de caracteres em valores de Single equivalentes.

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.

Comentários

No .NET Core 3.0 e posterior, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação do IEEE 754. Em versões anteriores, incluindo o .NET Framework, a análise de um valor muito grande para representar resultou em falha.

O parâmetro s pode conter o PositiveInfinitySymbolda cultura atual, NegativeInfinitySymbol, NaNSymbolou uma cadeia de caracteres do formulário:

[ws] [assinar] [de dígitos integrais [,]][.[de dígitos fracionários ]][e[de sinal de]de dígitos exponencial ][ws]

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

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

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

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

Normalmente, se você passar o método Parse uma cadeia de caracteres que é criada chamando o método ToString, o valor de Single original será retornado. No entanto, devido a uma perda de precisão, os valores podem não ser iguais.

Se s estiver fora do intervalo do tipo de dados Single, o método lançará um OverflowException no .NET Framework e no .NET Core 2.2 e versões anteriores. No .NET Core 3.0 e versões posteriores, ele retornará 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 parâmetro s durante uma operação de análise, e a moeda ou o número decimal aplicável e separadores de grupo forem os mesmos, a operação de análise pressupõe que o separador seja um separador decimal em vez de um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Confira também

Aplica-se a

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Origem:
Single.cs
Origem:
Single.cs

Analisa um intervalo de caracteres UTF-8 em um valor.

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

utf8Text
ReadOnlySpan<Byte>

O intervalo de caracteres UTF-8 a serem analisados.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre utf8Text.

Retornos

Single

O resultado da análise de utf8Text.

Implementações

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Origem:
Single.cs
Origem:
Single.cs
Origem:
Single.cs

Analisa um intervalo de caracteres em um valor.

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

s
ReadOnlySpan<Char>

O intervalo de caracteres a serem analisados.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

Single

O resultado da análise de s.

Implementações

Parse(ReadOnlySpan<Char>, IFormatProvider)

Aplica-se a

Parse(String, NumberStyles)

Origem:
Single.cs
Origem:
Single.cs
Origem:
Single.cs

Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu número de ponto flutuante de precisão única equivalente.

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

s
String

Uma cadeia de caracteres que contém um número a ser convertido.

style
NumberStyles

Uma combinação bit a bit de valores de enumeração que indica os elementos de estilo que podem estar presentes em s. Um valor típico a ser especificado é Float combinado com AllowThousands.

Retornos

Single

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

Exceções

ArgumentNullException

s é null.

FormatException

s não é um número em um formato válido.

OverflowException

Somente .NET Framework e .NET Core 2.2 e versões anteriores: s representa um número menor que Single.MinValue ou maior que Single.MaxValue.

ArgumentException

style não é um valor NumberStyles.

-ou-

style inclui o valor AllowHexSpecifier.

Exemplos

O exemplo a seguir usa o método Parse(String, NumberStyles) para analisar as representações de cadeia de caracteres de valores Single. O exemplo usa informações 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.

Comentários

No .NET Core 3.0 e posterior, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação do IEEE 754. Em versões anteriores, incluindo o .NET Framework, a análise de um valor muito grande para representar resultou em falha.

O parâmetro style define os elementos de estilo (como espaço em branco, milhares de separadores e símbolos de moeda) que são permitidos no parâmetro s para que a operação de análise tenha êxito. Deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Não há suporte para os seguintes membros NumberStyles:

O parâmetro s pode conter o PositiveInfinitySymbolda cultura atual, NegativeInfinitySymbol, NaNSymbol. Dependendo do valor de style, ele também pode assumir o formulário:

[ws] [$] [assinar] [de dígitos integrais [,]][.[de dígitos fracionários ]][E[sign]exponential-digits][ws]

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

ws uma série de caracteres de espaço em branco. O espaço em branco poderá aparecer no início do s se style incluir o sinalizador NumberStyles.AllowLeadingWhite e ele poderá aparecer no final do s se style incluir o sinalizador NumberStyles.AllowTrailingWhite.

$ Um símbolo de moeda específico à cultura. Sua posição na cadeia de caracteres é definida pelas propriedades NumberFormatInfo.CurrencyNegativePattern e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo de moeda da cultura atual pode aparecer em s se style incluir o sinalizador NumberStyles.AllowCurrencySymbol.

sinal um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+). O sinal poderá aparecer no início do s se style incluir o sinalizador de NumberStyles.AllowLeadingSign e ele poderá aparecer no final do s se style incluir o sinalizador NumberStyles.AllowTrailingSign. Parênteses podem ser usados em s para indicar um valor negativo se style incluir o sinalizador NumberStyles.AllowParentheses.

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

, um separador de grupo específico à cultura. O símbolo do separador de grupo da cultura atual pode aparecer no s se style incluir o sinalizador NumberStyles.AllowThousands

. Um símbolo de ponto decimal específico da cultura. O símbolo de ponto decimal da cultura atual pode aparecer em s se style incluir o sinalizador NumberStyles.AllowDecimalPoint.

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

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

dígitos exponencial uma série de dígitos que variam de 0 a 9 que especificam um expoente.

Nota

Todos os caracteres NUL de terminação (U+0000) em s são ignorados pela operação de análise, independentemente do valor do argumento style.

Uma cadeia de caracteres somente com dígitos (que corresponde ao estilo NumberStyles.None) sempre será analisada com êxito se estiver no intervalo do tipo Single. Os membros restantes System.Globalization.NumberStyles controlam elementos que podem estar presentes, mas não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como sinalizadores de NumberStyles individuais afetam os elementos que podem estar presentes no s.

Valor de NumberStyles Elementos permitidos em s além de dígitos
None O elemento de dígitos integrais apenas.
AllowDecimalPoint O ponto decimal (.) e dígitos fracionários elementos.
AllowExponent O caractere "e" ou "E", que indica notação exponencial. Esse sinalizador por si só dá suporte a valores no formulário dígitosdígitos deE; sinalizadores adicionais são necessários para analisar com êxito cadeias de caracteres com elementos como sinais positivos ou negativos e símbolos de ponto decimais.
AllowLeadingWhite O elemento ws no início de s.
AllowTrailingWhite O elemento ws no final de s.
AllowLeadingSign O elemento de sinal no início de .
AllowTrailingSign O elemento de sinal no final do .
AllowParentheses O sinal elemento na forma de parênteses que incluem o valor numérico.
AllowThousands O elemento separador de milhares (,).
AllowCurrencySymbol O elemento currency ($).
Currency Todos os elementos. No entanto, s não pode representar um número hexadecimal ou um número na notação exponencial.
Float O elemento ws no início ou no final de s, de sinal no início de se o símbolo de ponto decimal (.). O parâmetro s também pode usar notação exponencial.
Number Os elementos ws, sign, separador de milhares (,) e ponto decimal (.).
Any Todos os elementos. No entanto, s não pode representar um número hexadecimal.

Alguns exemplos de s são "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" e "-Infinity".

O parâmetro s é analisado usando as informações de formatação em um objeto NumberFormatInfo inicializado para a cultura atual do sistema. Para especificar a cultura cujas informações de formatação são usadas para a operação de análise, chame a sobrecarga de Parse(String, NumberStyles, IFormatProvider).

Normalmente, se você passar o método Parse uma cadeia de caracteres que é criada chamando o método ToString, o valor de Single original será retornado. No entanto, devido a uma perda de precisão, os valores podem não ser iguais.

Se s estiver fora do intervalo do tipo de dados Single, o método lançará um OverflowException no .NET Framework e no .NET Core 2.2 e versões anteriores. No .NET Core 3.0 e versões posteriores, ele retornará 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 parâmetro s durante uma operação de análise, e a moeda ou o número decimal aplicável e separadores de grupo forem os mesmos, a operação de análise pressupõe que o separador seja um separador decimal em vez de um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Confira também

Aplica-se a

Parse(String, IFormatProvider)

Origem:
Single.cs
Origem:
Single.cs
Origem:
Single.cs

Converte a representação de cadeia de caracteres de um número em um formato específico à cultura especificado em seu número de ponto flutuante de precisão única equivalente.

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

s
String

Uma cadeia de caracteres que contém um número a ser convertido.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

Single

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

Implementações

Parse(String, IFormatProvider)

Exceções

ArgumentNullException

s é null.

FormatException

s não representa um número em um formato válido.

OverflowException

Somente .NET Framework e .NET Core 2.2 e versões anteriores: s representa um número menor que Single.MinValue ou maior que Single.MaxValue.

Exemplos

O exemplo a seguir é o manipulador de eventos de clique de botão de um formulário da Web. Ele usa a matriz retornada pela propriedade HttpRequest.UserLanguages para determinar a localidade do usuário. Em seguida, cria uma instância de um objeto CultureInfo que corresponde a essa localidade. O objeto NumberFormatInfo que pertence a esse objeto CultureInfo é passado para o método Parse(String, IFormatProvider) para converter a entrada do usuário em um valor Single.

protected void OkToSingle_Click(object sender, EventArgs e)
{
    string locale;
    float number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Single.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (Exception)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}

Protected Sub OkToSingle_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToSingle.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Single

   ' Return if string is empty
   If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub

   ' Get locale of web request to determine possible format of number
   If Request.UserLanguages.Length = 0 Then Exit Sub
   locale = Request.UserLanguages(0)
   If String.IsNullOrEmpty(locale) Then Exit Sub

   ' Instantiate CultureInfo object for the user's locale
   culture = New CultureInfo(locale)

   ' Convert user input from a string to a number
   Try
      number = Single.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As OverflowException
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

Comentários

No .NET Core 3.0 e posterior, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação do IEEE 754. Em versões anteriores, incluindo o .NET Framework, a análise de um valor muito grande para representar resultou em falha.

Essa sobrecarga normalmente é usada para converter texto que pode ser formatado de várias maneiras para um valor Single. Por exemplo, ele pode ser usado para converter o texto inserido por um usuário em uma caixa de texto HTML em um valor numérico.

O parâmetro s é interpretado usando uma combinação dos sinalizadores NumberStyles.Float e NumberStyles.AllowThousands. O parâmetro s pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolou NumberFormatInfo.NaNSymbol para a cultura especificada por providerou pode conter uma cadeia de caracteres do formulário:

[ws] [sign]integral-digits[.[fractional-digits]][E[sign]exponential-digits][ws]

Elementos opcionais são emoldurados em colchetes ([ e ]). Os elementos que contêm o termo "dígitos" consistem em uma série de caracteres numéricos que variam de 0 a 9.

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

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

O parâmetro provider é uma implementação IFormatProvider cujo método GetFormat retorna um objeto NumberFormatInfo que fornece informações de formatação específicas da cultura. Quando o método Parse(String, IFormatProvider) é invocado, ele chama o método GetFormat do parâmetro provider e passa um objeto Type que representa o tipo NumberFormatInfo. O método GetFormat retorna o objeto NumberFormatInfo que fornece informações sobre o formato do parâmetro s. Há três maneiras de usar o parâmetro provider para fornecer informações de formatação personalizadas para a operação de análise:

  • Você pode passar um objeto CultureInfo que representa a cultura que fornece informações de formatação. Seu método GetFormat retorna o objeto NumberFormatInfo que fornece informações de formatação numérica para essa cultura.

  • Você pode passar o objeto NumberFormatInfo real que fornece informações de formatação numérica. (Sua implementação de GetFormat apenas retorna a si mesma.)

  • Você pode passar um objeto personalizado que implementa IFormatProvider. Seu método GetFormat cria uma instância e retorna o objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null ou um NumberFormatInfo não puder ser obtido, as informações de formatação para a cultura atual do sistema serão usadas.

Se s estiver fora do intervalo do tipo de dados Single, o método lançará um OverflowException no .NET Framework e no .NET Core 2.2 e versões anteriores. No .NET Core 3.0 e versões posteriores, ele retornará 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 parâmetro s durante uma operação de análise, e a moeda ou o número decimal aplicável e separadores de grupo forem os mesmos, a operação de análise pressupõe que o separador seja um separador decimal em vez de um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Alguns exemplos de s são "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" e "-Infinity".

Confira também

Aplica-se a

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Origem:
Single.cs
Origem:
Single.cs

Analisa um intervalo de caracteres UTF-8 em um valor.

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

utf8Text
ReadOnlySpan<Byte>

O intervalo de caracteres UTF-8 a serem analisados.

style
NumberStyles

Uma combinação bit a bit de estilos numéricos que podem estar presentes em utf8Text.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre utf8Text.

Retornos

Single

O resultado da análise de utf8Text.

Implementações

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Aplica-se a

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Origem:
Single.cs
Origem:
Single.cs
Origem:
Single.cs

Converte um intervalo de caracteres que contém a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu número de ponto flutuante de precisão única equivalente.

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

s
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o número a ser convertido.

style
NumberStyles

Uma combinação bit a bit de valores de enumeração que indicam os elementos de estilo que podem estar presentes em s. Um valor típico a ser especificado é Float combinado com AllowThousands.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

Single

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

Implementações

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Exceções

FormatException

s não representa um valor numérico.

ArgumentException

style não é um valor NumberStyles.

-ou-

style é o valor AllowHexSpecifier.

Comentários

No .NET Core 3.0 e posterior, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação do IEEE 754. Em versões anteriores, incluindo o .NET Framework, a análise de um valor muito grande para representar resultou em falha.

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

Aplica-se a

Parse(String, NumberStyles, IFormatProvider)

Origem:
Single.cs
Origem:
Single.cs
Origem:
Single.cs

Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu número de ponto flutuante de precisão única equivalente.

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

s
String

Uma cadeia de caracteres que contém um número a ser convertido.

style
NumberStyles

Uma combinação bit a bit de valores de enumeração que indica os elementos de estilo que podem estar presentes em s. Um valor típico a ser especificado é Float combinado com AllowThousands.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

Single

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

Implementações

Parse(String, NumberStyles, IFormatProvider)

Exceções

ArgumentNullException

s é null.

FormatException

s não representa um valor numérico.

ArgumentException

style não é um valor NumberStyles.

-ou-

style é o valor AllowHexSpecifier.

OverflowException

Somente .NET Framework e .NET Core 2.2 e versões anteriores: s representa um número menor que Single.MinValue ou maior que Single.MaxValue.

Exemplos

O exemplo de código a seguir usa o método Parse(String, NumberStyles, IFormatProvider) para analisar as representações de cadeia de caracteres de valores Single. Cada cadeia de caracteres em uma matriz é analisada usando as convenções de formatação do en-US, nl-NLe uma cultura personalizada. A cultura personalizada define seu símbolo separador de grupo como o sublinhado ("_") e seu tamanho de 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.

Comentários

No .NET Core 3.0 e posterior, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação do IEEE 754. Em versões anteriores, incluindo o .NET Framework, a análise de um valor muito grande para representar resultou em falha.

O parâmetro style define os elementos de estilo (como espaço em branco, milhares de separadores e símbolos de moeda) que são permitidos no parâmetro s para que a operação de análise tenha êxito. Deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Não há suporte para os seguintes membros NumberStyles:

O parâmetro s pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolou NumberFormatInfo.NaNSymbol para a cultura especificada por provider. Dependendo do valor de style, ele também pode assumir o formulário:

[ws] [$] [assinar] [de dígitos integrais ,]de dígitos integrais [.[de dígitos fracionários ]][E[sign]exponencial-digits][ws]

Elementos emoldurados em colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

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

Nota

Todos os caracteres NUL de terminação (U+0000) em s são ignorados pela operação de análise, independentemente do valor do argumento style.

Uma cadeia de caracteres somente com dígitos (que corresponde ao estilo NumberStyles.None) sempre será analisada com êxito se estiver no intervalo do tipo Single. Os membros restantes System.Globalization.NumberStyles controlam elementos que podem estar presentes, mas não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como sinalizadores de NumberStyles individuais afetam os elementos que podem estar presentes no s.

Valor de NumberStyles Elementos permitidos em s além de dígitos
None O elemento de dígitos integrais apenas.
AllowDecimalPoint O ponto decimal (.) e dígitos fracionários elementos.
AllowExponent O caractere "e" ou "E", que indica notação exponencial. Esse sinalizador por si só dá suporte a valores no formulário dígitosdígitos deE; sinalizadores adicionais são necessários para analisar com êxito cadeias de caracteres com elementos como sinais positivos ou negativos e símbolos de ponto decimais.
AllowLeadingWhite O elemento ws no início de s.
AllowTrailingWhite O elemento ws no final de s.
AllowLeadingSign O elemento de sinal no início de .
AllowTrailingSign O elemento de sinal no final do .
AllowParentheses O sinal elemento na forma de parênteses que incluem o valor numérico.
AllowThousands O elemento separador de milhares (,).
AllowCurrencySymbol O elemento currency ($).
Currency Todos os elementos. No entanto, s não pode representar um número hexadecimal ou um número na notação exponencial.
Float O elemento ws no início ou no final de s, de sinal no início de se o símbolo de ponto decimal (.). O parâmetro s também pode usar notação exponencial.
Number Os elementos ws, sign, separador de milhares (,) e ponto decimal (.).
Any Todos os elementos. No entanto, s não pode representar um número hexadecimal.

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

  • Um objeto CultureInfo que representa a cultura que fornece informações de formatação numérica. Seu método GetFormat retorna o objeto NumberFormatInfo que fornece informações de formatação numérica.

  • Um objeto NumberFormatInfo que fornece informações de formatação. (Sua implementação de GetFormat apenas retorna a si mesma.)

  • Um objeto personalizado que implementa IFormatProvider e usa o método GetFormat para instanciar e retornar o objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null, o objeto NumberFormatInfo da cultura atual será usado.

Se s estiver fora do intervalo do tipo de dados Single, o método lançará um OverflowException no .NET Framework e no .NET Core 2.2 e versões anteriores. No .NET Core 3.0 e versões posteriores, ele retornará 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 parâmetro s durante uma operação de análise, e a moeda ou o número decimal aplicável e separadores de grupo forem os mesmos, a operação de análise pressupõe que o separador seja um separador decimal em vez de um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Confira também

Aplica-se a