Single.TryParse Método

Definição

Espaço de Nomes:

System

Assemblagens:

netstandard.dll, System.Runtime.dll

Converte a representação da cadeia de um número para o seu equivalente em ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso ou falhou.

Sobrecargas

Name	Description
TryParse(String, IFormatProvider, Single)	Tenta analisar uma cadeia num valor.
TryParse(ReadOnlySpan<Char>, Single)	Converte a representação da cadeia de um número num intervalo de caracteres para o seu equivalente numérico em ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso ou falhou.
TryParse(String, Single)	Converte a representação da cadeia de um número para o seu equivalente em ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso ou falhou.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)	Tenta separar um intervalo de caracteres UTF-8 num valor.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)	Tenta separar um intervalo de caracteres num valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)	Tenta separar um intervalo de caracteres UTF-8 num valor.
TryParse(ReadOnlySpan<Byte>, Single)	Tenta converter um intervalo de caracteres UTF-8 contendo a representação de cadeias de um número para o seu equivalente em ponto flutuante de precisão simples.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Converte a representação span de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso ou falhou.
TryParse(String, NumberStyles, IFormatProvider, Single)	Converte a representação de cadeias de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso ou falhou.

Observações

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

TryParse(String, IFormatProvider, Single)

Origem:

Single.cs

Tenta analisar uma cadeia num 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 sequência a analisar.

provider

IFormatProvider

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

result

Single

Quando este método retorna, contém o resultado de uma s análise bem-sucedida ou um valor indefinido em caso de falha.

Devoluções

Boolean

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

TryParse(ReadOnlySpan<Char>, Single)

Origem:

Single.cs

Converte a representação da cadeia de um número num intervalo de caracteres para o seu equivalente numérico em ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso 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 em cadeia do número a converter.

result

Single

Quando este método retorna, contém o número de ponto flutuante de precisão simples equivalente ao s parâmetro, se a conversão foi bem-sucedida, ou zero se a conversão falhou. A conversão falha se o s parâmetro for null vazio ou não for um número num formato válido. Se s for um número válido menor que Single.MinValue, result é NegativeInfinity. Se s for um número válido maior que Single.MaxValue, result é PositiveInfinity. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido result será sobrescrito.

Devoluções

Boolean

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

Observações

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

TryParse(String, Single)

Origem:

Single.cs

Converte a representação da cadeia de um número para o seu equivalente em ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso 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 que representa um número a converter.

result

Single

Quando este método retorna, contém um número de ponto flutuante de precisão simples equivalente ao valor numérico ou símbolo contido em s, se a conversão foi bem-sucedida, ou zero se a conversão falhou. A conversão falha se o s parâmetro for null ou Empty não for um número num formato válido. Também falha no .NET Framework se s representar um número inferior a Single.MinValue ou superior a Single.MaxValue. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido result será sobrescrito.

Devoluções

Boolean

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

Exemplos

O exemplo seguinte utiliza o TryParse(String, Single) método para converter as representações de cadeias de valores numéricos em Single valores. 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

Observações

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

Esta sobrecarga difere do Single.Parse(String) método por devolver um valor booleano que indica se a operação de análise analisada teve sucesso, em vez de devolver o valor numérico analisado. Elimina a necessidade de usar o tratamento de exceções para testar a FormatException caso este s seja inválido e não possa ser analisado com sucesso.

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

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

Os elementos entre parênteses retos são opcionais. A tabela a seguir descreve cada elemento.

Elemento	Descrição
ws	Uma série de caracteres em espaços em branco.
assinar	Um sinal negativo ou símbolo positivo.
dígitos integrais	Uma série de caracteres numéricos de 0 a 9 que especificam a parte integral do número. Os dígitos integrais podem estar ausentes se existirem dígitos fracionários.
,	Um símbolo separador de grupo específico de cada cultura.
.	Um símbolo de ponto decimal específico para cada cultura.
Dígitos fracionários	Uma série de caracteres numéricos 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).
Dígitos exponenciais	Uma série de caracteres numéricos de 0 a 9 que especificam um expoente.

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

O s parâmetro é analisado usando a informação de formatação num NumberFormatInfo objeto que é inicializado para a cultura do sistema atual. Para obter mais informações, veja NumberFormatInfo.CurrentInfo. Para analisar uma string usando a informação de formatação de outra cultura especificada, use o TryParse(String, NumberStyles, IFormatProvider, Single) método overload.

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

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

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

Ver também

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

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)

Origem:

Single.cs

Tenta separar um intervalo de caracteres UTF-8 num 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>

A extensão de caracteres UTF-8 para analisar.

provider

IFormatProvider

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

result

Single

No retorno, contém o resultado de uma análise utf8Text bem-sucedida ou um valor indefinido em caso de falha.

Devoluções

Boolean

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

TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)

Origem:

Single.cs

Tenta separar um intervalo de caracteres num 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 número de personagens a analisar.

provider

IFormatProvider

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

result

Single

Quando este método retorna, contém o resultado de uma sanálise bem-sucedida , ou um valor indefinido em caso de falha.

Devoluções

Boolean

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

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

Origem:

Single.cs

Tenta separar um intervalo de caracteres UTF-8 num 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>

A extensão de caracteres UTF-8 para analisar.

style

NumberStyles

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

provider

IFormatProvider

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

result

Single

No retorno, contém o resultado de uma análise utf8Text bem-sucedida ou um valor indefinido em caso de falha.

Devoluções

Boolean

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

TryParse(ReadOnlySpan<Byte>, Single)

Origem:

Single.cs

Tenta converter um intervalo de caracteres UTF-8 contendo a representação de cadeias de um número para o seu equivalente em ponto flutuante de precisão simples.

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 apenas de leitura que contém o número a converter.

result

Single

Quando este método retorna, contém um número de ponto flutuante de precisão simples equivalente ao valor numérico ou símbolo contido em utf8Text se a conversão foi bem-sucedida, ou zero se a conversão falhou. A conversão falha se estiver utf8TextEmpty ou não estiver num formato válido. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido no resultado será sobrescrito.

Devoluções

Boolean

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

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

Origem:

Single.cs

Converte a representação span de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso 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 apenas de leitura que contém o número a converter. O vão é 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 especificar é Float combinado com AllowThousands.

provider

IFormatProvider

Um objeto que fornece informação de formatação específica de cultura sobre s.

result

Single

Quando este método retorna, contém o número de ponto flutuante de precisão simples equivalente ao valor numérico ou símbolo contido em s, se a conversão foi bem-sucedida, ou zero se a conversão falhou. A conversão falha se o s parâmetro for null ou Empty, não estiver num 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 NumberStyles constantes enumeradas. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido result será sobrescrito.

Devoluções

Boolean

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

Observações

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

TryParse(String, NumberStyles, IFormatProvider, Single)

Origem:

Single.cs

Converte a representação de cadeias de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de precisão simples. Um valor de retorno indica se a conversão teve sucesso 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 que representa um número a converter.

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 especificar é Float combinado com AllowThousands.

provider

IFormatProvider

Um objeto que fornece informação de formatação específica de cultura sobre s.

result

Single

Quando este método retorna, contém o número de ponto flutuante de precisão simples equivalente ao valor numérico ou símbolo contido em s, se a conversão foi bem-sucedida, ou zero se a conversão falhou. A conversão falha se o s parâmetro for null ou Empty, não estiver num formato compatível com style, ou se style não for uma combinação válida de NumberStyles constantes de enumeração. Também falha no .NET Framework se s representar um número inferior a Single.MinValue ou superior a Single.MaxValue. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido result será sobrescrito.

Devoluções

Boolean

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

Exceções

ArgumentException

style não é um NumberStyles valor.

-ou-

style é o AllowHexSpecifier valor.

Exemplos

O exemplo seguinte demonstra o uso do Single.TryParse(String, NumberStyles, IFormatProvider, Single) método para analisar a representação de cadeias de números que têm um estilo particular e são formatados segundo as convenções de uma cultura particular.

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'.

Observações

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

Esta sobrecarga difere do Parse(String, NumberStyles, IFormatProvider) método por devolver um valor booleano que indica se a operação de análise analisada teve sucesso, em vez de devolver o valor numérico analisado. Elimina a necessidade de usar o tratamento de exceções para testar a FormatException caso este s seja inválido e não possa ser analisado com sucesso.

O style parâmetro define o formato permitido do s parâmetro para que a operação de análise sintática tenha sucesso. Deve ser uma combinação de indicadores de bits da NumberStyles enumeração. Os seguintes NumberStyles membros não são apoiados:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

O s parâmetro pode conter PositiveInfinitySymbol, NegativeInfinitySymbol, ou NaNSymbol símbolo para a cultura indicado por provider. Esta comparação de strings é insensível a maiúsculas minúsculas no .NET Core 3.0 e versões posteriores, mas é sensível a maiúsculas minúsculas em versões anteriores, incluindo o .NET Framework. Além disso, dependendo do valor de style, o s parâmetro pode incluir os seguintes elementos:

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

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

Elemento	Descrição
ws	Espaço em branco opcional. O espaço em branco pode aparecer no início de s if style inclui a NumberStyles.AllowLeadingWhite bandeira. Pode aparecer no final de s se style incluir a NumberStyles.AllowTrailingWhite bandeira.
$	Um símbolo monetário específico de cada cultura. A sua posição na cadeia é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades ou NumberFormatInfo.CurrencyPositivePattern do NumberFormatInfo objeto devolvidas pelo IFormatProvider.GetFormat método do provider parâmetro. O símbolo da moeda pode aparecer se sstyle incluir a NumberStyles.AllowCurrencySymbol bandeira.
assinar	Um sinal opcional. O sinal pode aparecer no início de s se inclui a style bandeira, e pode aparecer no final de NumberStyles.AllowLeadingSign se s inclui a styleNumberStyles.AllowTrailingSign bandeira. Parênteses podem ser usados s para indicar um valor negativo se style incluir a NumberStyles.AllowParentheses bandeira.
dígitos integrais	Uma série de dígitos de 0 a 9 que especificam a parte integral do número. Os dígitos integrais podem estar ausentes se existirem dígitos fracionários.
,	Um símbolo separador de milhares específico de cultura. O símbolo separador dos milhares da cultura atual pode aparecer se sstyle incluir a NumberStyles.AllowThousands bandeira.
.	Um símbolo de ponto decimal específico para cada cultura. O símbolo de ponto decimal da cultura atual pode aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.
Dígitos fracionários	Uma série de dígitos de 0 a 9 que especificam a parte fracionária do número. Dígitos fracionários podem aparecer em s se style incluir a NumberStyles.AllowDecimalPoint bandeira.
e	O carácter e ou E, que indica que s pode representar um número usando notação exponencial. O s parâmetro pode representar um número em notação exponencial se o estilo incluir a NumberStyles.AllowExponent bandeira.
Dígitos exponenciais	Uma série de dígitos que variam de 0 a 9 que especificam um expoente.

Note

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

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

Valor de NumberStyles	Elementos permitidos em s além dos dígitos
None	Apenas o elemento de dígitos integrais .
AllowDecimalPoint	Os elementos de . e de dígitos fracionários.
AllowExponent	O s parâmetro também pode usar notação exponencial. Este flag, por si só, suporta valores na forma de dígitos integraisE dígitos exponenciais; São necessárias bandeiras adicionais para analisar com sucesso cadeias 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 signo no início de s.
AllowTrailingSign	O elemento signo no final de s.
AllowParentheses	O elemento do signo na forma de parênteses que envolvem o valor numérico.
AllowThousands	O elemento ,
AllowCurrencySymbol	O $ elemento.
Currency	Todos. O s parâmetro não pode representar um número hexadecimal ou um número em notação exponencial.
Float	O elemento ws no início ou fim de s, sinal no início de s, e o símbolo . O s parâmetro também pode usar notação exponencial.
Number	Os wselementos, sign, milhares, separadores (,), e ponto decimal (.).
Any	Todos os estilos, exceto s , não podem representar um número hexadecimal.

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

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

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

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

Se provider for null, a formatação de s é interpretada com base no NumberFormatInfo objeto da cultura atual.

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

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

Ver também

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