Single.TryParse Método

Definição

Namespace:

System

Assembly:

System.Runtime.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. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

Sobrecargas

TryParse(String, IFormatProvider, Single)	Tenta analisar uma cadeia de caracteres em um valor.
TryParse(ReadOnlySpan<Char>, Single)	Converte a representação de cadeia de caracteres de um número em um intervalo de caracteres em seu número de ponto flutuante de precisão única equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
TryParse(String, Single)	Converte a representação de cadeia de caracteres de um número em seu número de ponto flutuante de precisão única equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)	Tenta analisar um intervalo de caracteres em um valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Byte>, Single)	Tenta converter um intervalo de caracteres UTF-8 que contém a representação de cadeia de caracteres de um número em seu número de ponto flutuante de precisão única equivalente.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Converte a representação de intervalo de um número em um formato específico de estilo e cultura especificado em seu número de ponto flutuante de precisão única equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
TryParse(String, NumberStyles, IFormatProvider, Single)	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. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

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.

TryParse(String, IFormatProvider, Single)

Origem:

Single.cs

Tenta analisar uma cadeia de caracteres em um valor.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = IParsable<float>::TryParse;

public static bool TryParse (string? s, IFormatProvider? provider, out float result);

static member TryParse : string * IFormatProvider * single -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Single) As Boolean

Parâmetros

s

String

A cadeia de caracteres a ser analisada.

provider

IFormatProvider

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

result

Single

Quando esse método é retornado, contém o resultado da análise bem-sucedida de s ou de um valor indefinido sobre a falha.

Retornos

Boolean

true se s foi analisado com êxito; caso contrário, false.

TryParse(ReadOnlySpan<Char>, Single)

Origem:

Single.cs

Converte a representação de cadeia de caracteres de um número em um intervalo de caracteres em seu número de ponto flutuante de precisão única equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] float % result);

public static bool TryParse (ReadOnlySpan<char> s, out float result);

static member TryParse : ReadOnlySpan<char> * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Single) As Boolean

Parâmetros

s

ReadOnlySpan<Char>

>um intervalo de caracteres que contém a representação de cadeia de caracteres do número a ser convertido.

result

Single

Quando esse método é retornado, contém o número de ponto flutuante de precisão única equivalente do parâmetro s, se a conversão foi bem-sucedida ou zero se a conversão falhou. A conversão falhará se o parâmetro s estiver null ou vazio ou não for um número em um formato válido. Se s for um número válido menor que Single.MinValue, result será NegativeInfinity. Se s for um número válido maior que Single.MaxValue, result será PositiveInfinity. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido em result será substituído.

Retornos

Boolean

true se s foi convertido com êxito; caso contrário, false.

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.

TryParse(String, Single)

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. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] float % result);

public static bool TryParse (string? s, out float result);

static member TryParse : string * single -> bool

Public Shared Function TryParse (s As String, ByRef result As Single) As Boolean

Parâmetros

s

String

Uma cadeia de caracteres que representa um número a ser convertido.

result

Single

Quando esse método é retornado, contém um número de ponto flutuante de precisão única equivalente ao valor numérico ou símbolo contido em s, se a conversão tiver sido bem-sucedida ou zero se a conversão falhar. A conversão falhará se o parâmetro s for null ou Empty ou não for um número em um formato válido. Ele também falhará no .NET Framework e no .NET Core 2.2 e versões anteriores se s representar um número menor que Single.MinValue ou maior que Single.MaxValue. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido em result será substituído.

Retornos

Boolean

true se s foi convertido com êxito; caso contrário, false.

Exemplos

O exemplo a seguir usa o método TryParse(String, Single) para converter as representações de cadeia de caracteres de valores numéricos em valores Single. Ele pressupõe que en-US é a cultura atual.

string value;
float number;

// Parse a floating-point value with a thousands separator.
value = "1,643.57";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse a floating-point value with a currency symbol and a
// thousands separator.
value = "$1,643.57";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse value in exponential notation.
value = "-1.643e6";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse a negative integer value.
value = "-168934617882109132";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);
// The example displays the following output:
//       1643.57
//       Unable to parse '$1,643.57'.
//       -164300
//       -1.689346E+17

// Parse a floating-point value with a thousands separator.
let value = "1,643.57"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse a floating-point value with a currency symbol and a
// thousands separator.
let value = "$1,643.57"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse value in exponential notation.
let value = "-1.643e6"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse a negative integer value.
let value = "-168934617882109132"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."
// The example displays the following output:
//       1643.57
//       Unable to parse '$1,643.57'.
//       -164300
//       -1.689346E+17

Dim value As String
Dim number As Single

' Parse a floating-point value with a thousands separator.
value = "1,643.57"
If Single.TryParse(value, number) Then
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse a floating-point value with a currency symbol and a
' thousands separator.
value = "$1,643.57"
If Single.TryParse(value, number) Then
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse value in exponential notation.
value = "-1.643e6"
If Single.TryParse(value, number)
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse a negative integer number.
value = "-168934617882109132"
If Single.TryParse(value, number)
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If
' The example displays the following output:
'       1643.57
'       Unable to parse '$1,643.57'.
'       -1643000
'       -1.689346E+17

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 difere do método Single.Parse(String) retornando um valor booliano que indica se a operação de análise foi bem-sucedida em vez de retornar o valor numérico analisado. Elimina a necessidade de usar o tratamento de exceções para testar um FormatException caso s seja inválido e não possa ser analisado com êxito.

O parâmetro s pode conter PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol (a comparação de cadeia de caracteres diferencia maiúsculas de minúsculas) ou uma cadeia de caracteres do formulário:

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

Elementos em colchetes 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 sinal negativo ou um símbolo de sinal positivo.
de dígitos integrais	Uma série de caracteres numéricos que variam de 0 a 9 que especificam a parte integral do número. Dígitos integrais podem estar ausentes se houver dígitos fracionários.
,	Um símbolo de separador de grupo específico à cultura.
.	Um símbolo de ponto decimal específico da cultura.
de dígitos fracionários	Uma série de caracteres numéricos que variam de 0 a 9 que especificam a parte fracionária do número.
E	Um caractere maiúsculo ou minúsculo 'e', que indica notação exponencial (científica).
de dígitos exponencial	Uma série de caracteres numéricos 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 TryParse(String, NumberStyles, IFormatProvider, Single).

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 NumberFormatInfo.CurrentInfo. Para analisar uma cadeia de caracteres usando as informações de formatação de alguma outra cultura especificada, use a sobrecarga do método TryParse(String, NumberStyles, IFormatProvider, Single).

Normalmente, se você passar o método Single.TryParse uma cadeia de caracteres que é criada chamando o método Single.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 retornará false 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

• Parse(String)
• ToString()
• analisar cadeias de caracteres numéricas no .NET

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)

Origem:

Single.cs

Tenta analisar um intervalo de caracteres UTF-8 em um valor.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = IUtf8SpanParsable<float>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Single) As Boolean

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.

result

Single

No retorno, contém o resultado da análise bem-sucedida de utf8Text ou de um valor indefinido sobre a falha.

Retornos

Boolean

true se utf8Text foi analisado com êxito; caso contrário, false.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)

Origem:

Single.cs

Tenta analisar um intervalo de caracteres em um valor.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = ISpanParsable<float>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Single) As Boolean

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.

result

Single

Quando esse método é retornado, contém o resultado da análise bem-sucedida de sou um valor indefinido sobre a falha.

Retornos

Boolean

true se s foi analisado com êxito; caso contrário, false.

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)

Origem:

Single.cs

Tenta analisar um intervalo de caracteres UTF-8 em um valor.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

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.

result

Single

No retorno, contém o resultado da análise bem-sucedida de utf8Text ou de um valor indefinido sobre a falha.

Retornos

Boolean

true se utf8Text foi analisado com êxito; caso contrário, false.

TryParse(ReadOnlySpan<Byte>, Single)

Origem:

Single.cs

Tenta converter um intervalo de caracteres UTF-8 que contém 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 bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] float % result);

public static bool TryParse (ReadOnlySpan<byte> utf8Text, out float result);

static member TryParse : ReadOnlySpan<byte> * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Single) As Boolean

Parâmetros

utf8Text

ReadOnlySpan<Byte>

Um intervalo de caracteres UTF-8 somente leitura que contém o número a ser convertido.

result

Single

Quando esse método é retornado, contém um número de ponto flutuante de precisão única equivalente ao valor numérico ou símbolo contido em utf8Text se a conversão tiver sido bem-sucedida ou zero se a conversão falhar. A conversão falhará se o utf8Text estiver Empty ou não estiver em um formato válido. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido no resultado será substituído.

Retornos

Boolean

true se utf8Text foi convertido com êxito; caso contrário, false.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)

Origem:

Single.cs

Converte a representação de intervalo de um número em um formato específico de estilo e cultura especificado em seu número de ponto flutuante de precisão única equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

Parâmetros

s

ReadOnlySpan<Char>

Um intervalo de caracteres somente leitura que contém o número a ser convertido. O intervalo é interpretado usando o estilo especificado por style.

style

NumberStyles

Uma combinação bit a bit de valores de enumeração que indica o formato permitido de 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.

result

Single

Quando esse método retorna, contém o número de ponto flutuante de precisão única equivalente ao valor numérico ou símbolo contido em s, se a conversão tiver sido bem-sucedida ou zero se a conversão falhar. A conversão falhará se o parâmetro s for null ou Empty, não estiver em um formato compatível com style, representar um número menor que Single.MinValue ou maior que Single.MaxValue ou se style não for uma combinação válida de constantes enumeradas NumberStyles. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido em result será substituído.

Retornos

Boolean

true se s foi convertido com êxito; caso contrário, false.

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.

TryParse(String, NumberStyles, IFormatProvider, Single)

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. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

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

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

Parâmetros

s

String

Uma cadeia de caracteres que representa um número a ser convertido.

style

NumberStyles

Uma combinação bit a bit de valores de enumeração que indica o formato permitido de 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.

result

Single

Quando esse método retorna, contém o número de ponto flutuante de precisão única equivalente ao valor numérico ou símbolo contido em s, se a conversão tiver sido bem-sucedida ou zero se a conversão falhar. A conversão falhará se o parâmetro s for null ou Empty, não estiver em um formato compatível com styleou se style não for uma combinação válida de constantes de enumeração NumberStyles. Ele também falhará no .NET Framework ou no .NET Core 2.2 e versões anteriores se s representar um número menor que Single.MinValue ou maior que Single.MaxValue. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido em result será substituído.

Retornos

Boolean

true se s foi convertido com êxito; caso contrário, false.

Exceções

ArgumentException

style não é um valor NumberStyles.

-ou-

style é o valor AllowHexSpecifier.

Exemplos

O exemplo a seguir demonstra o uso do método Single.TryParse(String, NumberStyles, IFormatProvider, Single) para analisar a representação de cadeia de caracteres de números que têm um estilo específico e são formatados usando as convenções de uma cultura específica.

string value;
System.Globalization.NumberStyles style;
System.Globalization.CultureInfo culture;
float number;

// Parse currency value using en-GB culture.
value = "£1,097.63";
style = System.Globalization.NumberStyles.Number |
        System.Globalization.NumberStyles.AllowCurrencySymbol;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1345,978";
style = System.Globalization.NumberStyles.AllowDecimalPoint;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1.345,978";
style = System.Globalization.NumberStyles.AllowDecimalPoint |
        System.Globalization.NumberStyles.AllowThousands;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("es-ES");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1 345,978";
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// The example displays the following output:
//       Converted '£1,097.63' to 1097.63.
//       Converted '1345,978' to 1345.978.
//       Converted '1.345,978' to 1345.978.
//       Unable to convert '1 345,978'.

// Parse currency value using en-GB culture.
let value = "£1,097.63"
let style = System.Globalization.NumberStyles.Number ||| System.Globalization.NumberStyles.AllowCurrencySymbol
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1345,978"
let style = System.Globalization.NumberStyles.AllowDecimalPoint
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1.345,978"
let style = System.Globalization.NumberStyles.AllowDecimalPoint ||| System.Globalization.NumberStyles.AllowThousands
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "es-ES"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1 345,978"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// The example displays the following output:
//       Converted '£1,097.63' to 1097.63.
//       Converted '1345,978' to 1345.978.
//       Converted '1.345,978' to 1345.978.
//       Unable to convert '1 345,978'.

Dim value As String
Dim style As System.Globalization.NumberStyles
Dim culture As System.Globalization.CultureInfo
Dim number As Single

' Parse currency value using en-GB culture.
value = "£1,097.63"
style = System.Globalization.NumberStyles.Number Or _
        System.Globalization.NumberStyles.AllowCurrencySymbol
culture = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1345,978"
style = System.Globalization.NumberStyles.AllowDecimalPoint
culture = System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1.345,978"
style = System.Globalization.NumberStyles.AllowDecimalPoint Or _
        System.Globalization.NumberStyles.AllowThousands
culture = System.Globalization.CultureInfo.CreateSpecificCulture("es-ES")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1 345,978"
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If
' The example displays the following output:
'       Converted '£1,097.63' to 1097.63.
'       Converted '1345,978' to 1345.978.
'       Converted '1.345,978' to 1345.978.
'       Unable to convert '1 345,978'.

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 difere do método Parse(String, NumberStyles, IFormatProvider) retornando um valor booliano que indica se a operação de análise foi bem-sucedida em vez de retornar o valor numérico analisado. Elimina a necessidade de usar o tratamento de exceções para testar um FormatException caso s seja inválido e não possa ser analisado com êxito.

O parâmetro style define o formato permitido do parâmetro s para que a operação de análise seja bem-sucedida. Deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Não há suporte para os seguintes membros NumberStyles:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

O parâmetro s pode conter PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol para a cultura indicada por provider. Além disso, dependendo do valor de style, o parâmetro s pode incluir os seguintes elementos:

[ws] [$] [sign] [integral-digits,]integral-digits[.fractional-digits][e[sign]exponential-digits][ws]

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

Elemento	Descrição
ws	Espaço em branco opcional. O espaço em branco poderá aparecer no início de s se style incluir o sinalizador NumberStyles.AllowLeadingWhite. Ele poderá aparecer no final do s se style incluir o sinalizador de NumberStyles.AllowTrailingWhite.
$	Um símbolo de moeda específico à cultura. Sua posição na cadeia de caracteres é definida pelas propriedades NumberFormatInfo.CurrencyNegativePattern ou NumberFormatInfo.CurrencyPositivePattern do objeto NumberFormatInfo retornado pelo método IFormatProvider.GetFormat do parâmetro provider. O símbolo de moeda poderá aparecer em s se style incluir o sinalizador NumberStyles.AllowCurrencySymbol.
assinar	Um sinal opcional. 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. Dígitos integrais podem estar ausentes se houver dígitos fracionários.
,	Um símbolo separador de milhares específico à cultura. O símbolo separador de milhares da cultura atual pode aparecer em 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 s pode representar um número usando notação exponencial. O parâmetro s pode representar um número na notação exponencial se o estilo 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, 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 . e elementos de dígitos fracionários.
AllowExponent	O parâmetro s também pode usar notação exponencial. Esse sinalizador por si só dá suporte a valores na forma dígitos integraisde dígitos exponencialE; sinalizadores adicionais são necessários para analisar com êxito cadeias de caracteres em notação exponencial 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 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 ,.
AllowCurrencySymbol	O elemento $.
Currency	Todo. O parâmetro 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, assinar no início do se no . símbolo. 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 estilos, exceto s não podem representar um número hexadecimal.

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 TryParse(String, NumberStyles, IFormatProvider, Single) é 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, a formatação de s será interpretada com base no objeto NumberFormatInfo da cultura atual.

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

• Parse(String)
• ToString()
• analisar cadeias de caracteres numéricas no .NET