Single.Parse Método

  • Referência

Definição

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

Converte a representação da cadeia de caracteres de um número no número de ponto flutuante de precisão simples equivalente.

Sobrecargas

Parse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um estilo e formato específico da cultura especificados em seu equivalente de número de ponto flutuante de precisão simples.
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 da cultura e um estilo especificados para o número de ponto flutuante de precisão simples equivalente.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(String, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato específico da cultura para o número de ponto flutuante de precisão simples equivalente.
Parse(String)

Converte a representação da cadeia de caracteres de um número no número de ponto flutuante de precisão simples equivalente.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

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

Converte a representação de cadeia de caracteres de um número em um estilo especificado para o número de ponto flutuante de precisão simples 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 .NET Framework, a análise de um valor muito grande para representar resultou em falha.

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 estilo e formato específico da cultura especificados em seu equivalente de número de ponto flutuante de precisão simples.

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

Um 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 para ser especificado é uma combinação de Float 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 simples equivalente ao valor numérico ou ao símbolo especificado em s.

Implementações

Parse(String, NumberStyles, IFormatProvider)

Exceções

ArgumentNullException

s é null.

FormatException

O s não representa um valor numérico.

ArgumentException

style não é um valor NumberStyles.

- ou -

style é o valor AllowHexSpecifier.

OverflowException

.NET Framework e .NET Core 2.2 e somente 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 Parse(String, NumberStyles, IFormatProvider) método para analisar as representações de cadeia de caracteres de Single valores. Cada cadeia de caracteres em uma matriz é analisada usando as convenções de formatação do en-US, nl-NL e 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 posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .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, separadores de milhares e símbolos de moeda) que são permitidos no parâmetro s para que a operação de análise seja bem-sucedida. Ele deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Os seguintes membros NumberStyles não são suportados:

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

[ws] [$] [sign][integral-digits,]integral-digits[.[ dígitos fracionários]] [E[sign]exponential-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. Espaço em branco pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingWhite e pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingWhite.
$ Um símbolo de moeda específico de cultura. A 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 ser exibido em s caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol.
sign Um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+). O sinal pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingSign e ele pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingSign. Os parênteses podem ser usados em s para indicar um valor negativo caso style inclua o sinalizador NumberStyles.AllowParentheses.
dígitos integrais Uma série de dígitos que varia de 0 a 9 que especificam a parte integral do número. O elemento de dígitos integrais poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários .
, Um separador de grupo específico de cultura. O símbolo do separador do grupo da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowThousands
. Um símbolo de vírgula decimal específico de cultura. O símbolo da vírgula decimal da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowDecimalPoint.
dígitos fracionários Uma série de dígitos que varia de 0 a 9 que especificam a parte fracionária do número. Os dígitos fracionários podem ser exibidos em s caso style inclua o sinalizador NumberStyles.AllowDecimalPoint.
E O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O parâmetro s pode representar um número em notação exponencial caso style inclua o sinalizador NumberStyles.AllowExponent.
dígitos exponenciais Uma série de dígitos que varia de 0 a 9 que especificam um expoente.

Observação

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

Uma cadeia de caracteres apenas com dígitos (que corresponde ao estilo NumberStyles.None ) sempre é analisada com Single êxito. Os elementos de controle dos membros System.Globalization.NumberStyles restantes que podem estar presentes, mas que não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como os sinalizadores individuais NumberStyles afetam os elementos que podem estar presentes em s.

Valor NumberStyles Elementos permitidos em s além de dígitos
None Somente o elemento de dígitos integrais .
AllowDecimalPoint Os elementos de ponto decimal (.) e de dígitos fracionários .
AllowExponent O caractere "e" ou "E", que indica a notação exponencial. Esse sinalizador por si só dá suporte a valores nos dígitosde formulário Edígitos; 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 decimal.
AllowLeadingWhite O elemento ws no início de s.
AllowTrailingWhite O elemento ws no final de s.
AllowLeadingSign O elemento sinal no início de s.
AllowTrailingSign O elemento sinal no final de s.
AllowParentheses O elemento sinal na forma de parênteses que incluem o valor numérico.
AllowThousands O elemento separador de milhares (.).
AllowCurrencySymbol O elemento de 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 final de s, assina no início de se o símbolo de ponto decimal (.). O parâmetro s também pode usar notação exponencial.
Number O ws, sign, separador de milhares (.) e elementos de vírgula decimal (,).
Any Todos os elementos. No entanto, s não pode representar um número hexadecimal.

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

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

  • Um NumberFormatInfo objeto que fornece informações de formatação. (Sua implementação de GetFormat retorna apenas ele próprio.)

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

Caso provider seja null, o objeto NumberFormatInfo da cultura atual é usado.

Se s estiver fora do intervalo do tipo de Single dados, 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.

Caso um separador esteja no parâmetro s durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e NumberGroupSeparator.

Confira também

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 da cultura e um estilo especificados para o número de ponto flutuante de precisão simples 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 para ser especificado é uma combinação de Float 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 simples que é equivalente ao valor numérico ou ao símbolo especificado em s.

Implementações

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Exceções

FormatException

O 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 posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .NET Framework, a análise de um valor muito grande para representar resultou em falha.

Se s estiver fora do intervalo do tipo de Single dados, 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(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 à cultura sobre utf8Text.

Retornos

Single

O resultado da análise utf8Text.

Implementações

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

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 da cultura para o número de ponto flutuante de precisão simples 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 de cultura sobre s.

Retornos

Single

Um número de ponto flutuante de precisão simples equivalente ao valor numérico ou ao 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

.NET Framework e .NET Core 2.2 e somente 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 do 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, ele instancia um objeto CultureInfo que corresponde à localidade. O NumberFormatInfo objeto que pertence a esse CultureInfo objeto é então passado para o Parse(String, IFormatProvider) método para converter a entrada do usuário em um 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

Comentários

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

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

O parâmetro s é interpretado usando-se uma combinação dos sinalizadores NumberStyles.Float e NumberStyles.AllowThousands. O s parâmetro 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] dígitos integrais[.[dígitos fracionários]] [E[sign]exponential-digits] [ws]

Os elementos opcionais são colocados entre colchetes ([ e ]). Os elementos que contêm o termo "digits" consistem em uma série de caracteres numéricos que varia de 0 a 9.

Elemento Descrição
ws Uma série de caracteres de espaço em branco.
sign Um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+).
dígitos integrais Uma série de dígitos que varia 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 poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários .
. Um símbolo de vírgula decimal específico de cultura.
dígitos fracionários Uma série de dígitos que varia 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 em notação exponencial (científica).
dígitos exponenciais Uma série de dígitos que varia 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 provider parâmetro é uma implementação IFormatProvider cujo GetFormat método retorna um NumberFormatInfo objeto que fornece informações de formatação específicas da cultura. Quando o Parse(String, IFormatProvider) método é invocado, ele chama o provider método do GetFormat parâmetro e passa a ele um Type objeto que representa o NumberFormatInfo tipo. Em GetFormat seguida, o método retorna o NumberFormatInfo objeto que fornece informações sobre o formato do s parâmetro. Existem três maneiras de usar o parâmetro provider para fornecer informações de formatação personalizadas para a operação de análise:

  • É possível passar um objeto CultureInfo que representa a cultura que fornece informações de formatação. O método GetFormat retorna o objeto NumberFormatInfo que fornece informações de formatação numérica para essa cultura.

  • É possível passar o objeto real NumberFormatInfo que fornece informações de formatação numérica. (Sua implementação de GetFormat retorna apenas ele próprio.)

  • É possível passar um objeto personalizado que implementa IFormatProvider. O método GetFormat cria uma instância e retorna o objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null ou não NumberFormatInfo 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 Single dados, 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.

Caso um separador esteja no parâmetro s durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e 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(String)

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

Converte a representação da cadeia de caracteres de um número no número de ponto flutuante de precisão simples 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 simples equivalente ao valor numérico ou ao símbolo especificado em s.

Exceções

ArgumentNullException

s é null.

FormatException

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

OverflowException

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

Exemplos

O exemplo a seguir usa o Parse(String) método para converter uma matriz de cadeias de caracteres 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.

Comentários

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

O s parâmetro pode conter , , NaNSymbolou uma cadeia de caracteres da cultura PositiveInfinitySymbolNegativeInfinitySymbolatual do formulário:

[ws] [sign] [dígitos integrais[,]] dígitos integrais[.[dígitos fracionários]] [e[sign]exponential-digits] [ws]

Os elementos entre 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.
sign Um símbolo de sinal negativo ou um símbolo de sinal positivo. Os caracteres de sinal válido são determinados pelas propriedades NumberFormatInfo.NegativeSign e NumberFormatInfo.PositiveSign da cultura atual. Somente um sinal à esquerda pode ser usado.
dígitos integrais Uma série de dígitos que varia 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 poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários .
, Um símbolo de separador de milhares específico da cultura.
. Um símbolo de vírgula decimal específico de cultura.
dígitos fracionários Uma série de dígitos que varia 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 em notação exponencial (científica).
dígitos exponenciais Uma série de dígitos que varia de 0 a 9 que especificam um expoente.

O parâmetro s é interpretado usando-se uma combinação dos sinalizadores NumberStyles.Float e NumberStyles.AllowThousands. Isso 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, milhares de separadores e espaço em branco) que podem estar presentes no s, use a sobrecarga do Parse(String, NumberStyles) método.

O parâmetro s é analisado usando-se as informações de formatação em um objeto NumberFormatInfo que é inicializado para a cultura do sistema atual. 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 Parse(String, IFormatProvider) método ou Parse(String, NumberStyles, IFormatProvider) .

Normalmente, se você passa ao método Parse, uma cadeia de caracteres criada chamando-se o método ToString, o valor Single original é retornado. No entanto, por conta de uma perda de precisão, os valores talvez não sejam iguais.

Se s estiver fora do intervalo do tipo de Single dados, 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.

Caso um separador esteja no parâmetro s durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e NumberGroupSeparator.

Confira também

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 à cultura sobre s.

Retornos

Single

O resultado da análise de s.

Implementações

Parse(ReadOnlySpan<Char>, IFormatProvider)

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 à cultura sobre utf8Text.

Retornos

Single

O resultado da análise de utf8Text.

Implementações

Parse(ReadOnlySpan<Byte>, 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 para o número de ponto flutuante de precisão simples 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

Um 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 para ser especificado é uma combinação de Float com AllowThousands.

Retornos

Single

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

Exceções

ArgumentNullException

s é null.

FormatException

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

OverflowException

.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 Parse(String, NumberStyles) método para analisar as representações de cadeia de caracteres de Single valores. 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 .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, separadores de milhares e símbolos de moeda) que são permitidos no parâmetro s para que a operação de análise seja bem-sucedida. Ele deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Os seguintes membros NumberStyles não são suportados:

O s parâmetro pode conter o da PositiveInfinitySymbolcultura atual, NegativeInfinitySymbol, NaNSymbol. Dependendo do valor de style, ele também pode assumir a forma:

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

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

Ws Uma série de caracteres de espaço em branco. Espaço em branco pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingWhite e pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingWhite.

$ Um símbolo de moeda específico da cultura. A 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 ser exibido em s caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol.

Sinal Um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+). O sinal pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingSign e ele pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingSign. Os parênteses podem ser usados em s para indicar um valor negativo caso style inclua 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 poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários .

, um separador de grupo específico da cultura. O símbolo do separador do grupo da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowThousands

. Um símbolo de vírgula decimal específico de cultura. O símbolo da vírgula decimal da cultura atual pode ser exibido em s caso style inclua 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. Os dígitos fracionários podem ser exibidos em s caso style inclua o sinalizador NumberStyles.AllowDecimalPoint.

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

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

Observação

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

Uma cadeia de caracteres apenas com dígitos (que corresponde ao estilo NumberStyles.None ) sempre é analisada com Single êxito. Os elementos de controle dos membros System.Globalization.NumberStyles restantes que podem estar presentes, mas que não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como os sinalizadores individuais NumberStyles afetam os elementos que podem estar presentes em s.

Valor NumberStyles Elementos permitidos em s além de dígitos
None Somente o elemento de dígitos integrais .
AllowDecimalPoint Os elementos de ponto decimal (.) e dígitos fracionários .
AllowExponent O caractere "e" ou "E", que indica a notação exponencial. Esse sinalizador por si só dá suporte a valores nos dígitosde formulário Edígitos; sinalizadores adicionais são necessários para analisar cadeias de caracteres com êxito 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 sinal no início de s.
AllowTrailingSign O elemento sinal no final de s.
AllowParentheses O elemento sinal na forma de parênteses que incluem o valor numérico.
AllowThousands O elemento separador de milhares (.).
AllowCurrencySymbol O elemento de 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 final de s, assina no início de se o símbolo de ponto decimal (.). O parâmetro s também pode usar notação exponencial.
Number O ws, sign, separador de milhares (.) e elementos de vírgula 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-se as informações de formatação em um objeto NumberFormatInfo que é inicializado para a cultura do sistema atual. Para especificar a cultura cujas informações de formatação são usadas para a operação de análise, chame a Parse(String, NumberStyles, IFormatProvider) sobrecarga.

Normalmente, se você passa ao método Parse, uma cadeia de caracteres criada chamando-se o método ToString, o valor Single original é retornado. No entanto, por conta de uma perda de precisão, os valores talvez não sejam iguais.

Se s estiver fora do intervalo do tipo de Single dados, 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.

Caso um separador esteja no parâmetro s durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e NumberGroupSeparator.

Confira também

Aplica-se a