Double.TryParse Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Converte a representação da cadeia de caracteres de um número no equivalente do número de ponto flutuante de precisão dupla. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
Sobrecargas
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Tenta analisar um intervalo de caracteres em um valor. |
TryParse(ReadOnlySpan<Char>, Double) |
Converte a representação de intervalo de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou. |
TryParse(String, Double) |
Converte a representação da cadeia de caracteres de um número no equivalente do número de ponto flutuante de precisão dupla. Um valor retornado indica se a conversão foi bem-sucedida ou falhou. |
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Tenta analisar um intervalo de caracteres UTF-8 em um valor. |
TryParse(String, IFormatProvider, Double) |
Tenta analisar uma cadeia de caracteres em um valor. |
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double) |
Tenta analisar um intervalo de caracteres UTF-8 em um valor. |
TryParse(ReadOnlySpan<Byte>, Double) |
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 dupla equivalente. |
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double) |
Converte um intervalo de caracteres que contém a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou. |
TryParse(String, NumberStyles, IFormatProvider, Double) |
Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou. |
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 o .NET Framework, a análise de um valor muito grande para representar resultou em falha.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Tenta analisar um intervalo de caracteres em um valor.
public:
static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = ISpanParsable<double>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out double result);
static member TryParse : ReadOnlySpan<char> * IFormatProvider * double -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Double) 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 à cultura sobre s
.
- result
- Double
Quando esse método retorna, contém o resultado da análise s
bem-sucedida de ou um valor indefinido em caso de falha.
Retornos
true
se s
foi analisado com êxito; caso contrário, false
.
Aplica-se a
TryParse(ReadOnlySpan<Char>, Double)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte a representação de intervalo de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
public:
static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] double % result);
public static bool TryParse (ReadOnlySpan<char> s, out double result);
static member TryParse : ReadOnlySpan<char> * double -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Double) 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 converter.
- result
- Double
Quando esse método é retornado, ele contém o número de ponto flutuante de precisão dupla equivalente ao valor numérico ou símbolo contido no parâmetro s
, caso a conversão seja bem-sucedida, ou contém zero, caso a conversão falhe. A conversão falhará se o parâmetro s
for null
, vazio ou se não estiver em um formato em conformidade com style
. A conversão também falhará se style
não for uma combinação válida de constantes enumeradas de NumberStyles. Se s
for um número válido menor que Double.MinValue, result
será NegativeInfinity. Se s
for um número válido maior que Double.MaxValue, result
será PositiveInfinity. Este parâmetro é passado não inicializado; qualquer valor fornecido originalmente em result
será substituído.
Retornos
true
caso s
tenha sido convertido com êxito; do 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 resultava em falha.
Aplica-se a
TryParse(String, Double)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte a representação da cadeia de caracteres de um número no equivalente do número de ponto flutuante de precisão dupla. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
public:
static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] double % result);
public static bool TryParse (string s, out double result);
public static bool TryParse (string? s, out double result);
static member TryParse : string * double -> bool
Public Shared Function TryParse (s As String, ByRef result As Double) As Boolean
Parâmetros
- s
- String
Uma cadeia de caracteres que contém um número a ser convertido.
- result
- Double
Quando esse método retorna, contém o equivalente do número de ponto flutuante de precisão dupla 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
for null
, Empty ou não for um número em 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 Double.MinValue ou maior que Double.MaxValue. Este parâmetro é passado não inicializado; qualquer valor fornecido originalmente em result
será substituído.
Retornos
true
caso s
tenha sido convertido com êxito; do contrário, false
.
Exemplos
O exemplo a seguir usa o TryParse(String, Double) método para converter as representações de cadeia de caracteres de valores numéricos em Double valores. Ele pressupõe que en-US é a cultura atual.
using System;
public class Example
{
public static void Main()
{
string[] values = { "1,643.57", "$1,643.57", "-1.643e6",
"-168934617882109132", "123AE6",
null, String.Empty, "ABCDEF" };
double number;
foreach (var value in values) {
if (Double.TryParse(value, out number))
Console.WriteLine("'{0}' --> {1}", value, number);
else
Console.WriteLine("Unable to parse '{0}'.", value);
}
}
}
// The example displays the following output:
// '1,643.57' --> 1643.57
// Unable to parse '$1,643.57'.
// '-1.643e6' --> -1643000
// '-168934617882109132' --> -1.68934617882109E+17
// Unable to parse '123AE6'.
// Unable to parse ''.
// Unable to parse ''.
// Unable to parse 'ABCDEF'.
open System
let values =
[| "1,643.57"; "$1,643.57"; "-1.643e6"
"-168934617882109132"; "123AE6"
null; String.Empty; "ABCDEF" |]
for value in values do
match Double.TryParse value with
| true, number ->
printfn $"'{value}' --> {number}"
| _ ->
printfn $"Unable to parse '{value}'."
// The example displays the following output:
// '1,643.57' --> 1643.57
// Unable to parse '$1,643.57'.
// '-1.643e6' --> -1643000
// '-168934617882109132' --> -1.68934617882109E+17
// Unable to parse '123AE6'.
// Unable to parse ''.
// Unable to parse ''.
// Unable to parse 'ABCDEF'.
Module Example
Public Sub Main()
Dim values() As String = { "1,643.57", "$1,643.57", "-1.643e6",
"-168934617882109132", "123AE6",
Nothing, String.Empty, "ABCDEF" }
Dim number As Double
For Each value In values
If Double.TryParse(value, number) Then
Console.WriteLine("'{0}' --> {1}", value, number)
Else
Console.WriteLine("Unable to parse '{0}'.", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' '1,643.57' --> 1643.57
' Unable to parse '$1,643.57'.
' '-1.643e6' --> -1643000
' '-168934617882109132' --> -1.68934617882109E+17
' Unable to parse '123AE6'.
' Unable to parse ''.
' Unable to parse ''.
' Unable to parse 'ABCDEF'.
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 resultava em falha.
Essa sobrecarga difere do Double.Parse(String) método 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. Ele elimina a necessidade de usar a identificação de exceções para testar um FormatException caso esse s
seja inválido e não possa ser analisado com êxito.
O s
parâmetro pode conter , NumberFormatInfo.PositiveInfinitySymbolNumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.NaNSymbol (a comparação de cadeia de caracteres diferencia maiúsculas de minúsculas) ou uma cadeia de caracteres do formulário:
[ws] [sign] [dígitos integrais,]dígitos integrais[.[ fractional-digits]][e[sign]exponential-digits][ws]
Os elementos entre 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. |
sign | Um símbolo de sinal negativo ou de sinal positivo. |
dígitos integrais | Uma série de caracteres numéricos que variam de 0 a 9 que especificam a parte integral do número. Os dígitos integrais podem estar ausentes caso sejam dígitos fracionários. |
, | Um símbolo de separador do grupo específico da cultura. |
. | Um símbolo de vírgula decimal específico de cultura. |
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). |
dígitos exponenciais | Uma série de caracteres numéricos que variam de 0 a 9 que especificam um expoente. |
Para obter mais informações sobre formatos numéricos, consulte Tipos de formatação.
O s
parâmetro é interpretado usando uma combinação dos NumberStyles.Float sinalizadores 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 Double.TryParse(String, NumberStyles, IFormatProvider, Double) 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 NumberFormatInfo.CurrentInfo. Para analisar uma cadeia de caracteres usando as informações de formatação de alguma outra cultura especificada, use a sobrecarga do Double.TryParse(String, NumberStyles, IFormatProvider, Double) método.
Normalmente, se você passa ao método Double.TryParse, uma cadeia de caracteres criada chamando-se o método Double.ToString, o valor Double original é retornado. No entanto, por conta de uma perda de precisão, os valores talvez não sejam iguais. Além disso, a tentativa de analisar a representação de cadeia de caracteres de Double.MinValue ou falha na viagem de ida e Double.MaxValue volta. No .NET Framework e no .NET Core 2.2 e nas versões anteriores, ele lança um OverflowException. No .NET Core 3.0 e versões posteriores, ele retornará Double.NegativeInfinity se você tentar analisar MinValue ou Double.PositiveInfinity se você tentar analisar MaxValue. O exemplo a seguir ilustra esse cenário.
using System;
public class Example
{
public static void Main()
{
string value;
double number;
value = Double.MinValue.ToString();
if (Double.TryParse(value, out number))
Console.WriteLine(number);
else
Console.WriteLine("{0} is outside the range of a Double.",
value);
value = Double.MaxValue.ToString();
if (Double.TryParse(value, out number))
Console.WriteLine(number);
else
Console.WriteLine("{0} is outside the range of a Double.",
value);
}
}
// The example displays the following output:
// -1.79769313486232E+308 is outside the range of the Double type.
// 1.79769313486232E+308 is outside the range of the Double type.
open System
[<EntryPoint>]
let main _ =
let value = string Double.MinValue
match Double.TryParse value with
| true, number ->
printfn $"{number}"
| _ ->
printfn $"{value} is outside the range of a Double."
let value = string Double.MaxValue
match Double.TryParse value with
| true, number ->
printfn $"{number}"
| _ ->
printfn $"{value} is outside the range of a Double."
0
// The example displays the following output:
// -1.79769313486232E+308 is outside the range of the Double type.
// 1.79769313486232E+308 is outside the range of the Double type.
Module Example
Public Sub Main()
Dim value As String
Dim number As Double
value = Double.MinValue.ToString()
If Double.TryParse(value, number) Then
Console.WriteLine(number)
Else
Console.WriteLine("{0} is outside the range of a Double.", _
value)
End If
value = Double.MaxValue.ToString()
If Double.TryParse(value, number) Then
Console.WriteLine(number)
Else
Console.WriteLine("{0} is outside the range of a Double.", _
value)
End If
End Sub
End Module
' The example displays the following output:
' -1.79769313486232E+308 is outside the range of the Double type.
' 1.79769313486232E+308 is outside the range of the Double type.
No .NET Framework e no .NET Core 2.2 e em versões anteriores, se s
estiver fora do intervalo do tipo de Double dados, o TryParse(String, Double) método gerará um OverflowException.
No .NET Core 3.0 e versões posteriores, nenhuma exceção é gerada quando s
está fora do intervalo do Double tipo de dados. Na maioria dos casos, o TryParse(String, Double) método calcula um resultado de Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, há um pequeno conjunto de valores que são considerados mais próximos dos valores máximos ou mínimos de Double do que ao infinito positivo ou negativo. Nesses casos, o método calcula um resultado de Double.MaxValue ou Double.MinValue.
Se um separador for encontrado no s
parâmetro durante uma operação de análise e os separadores decimais e 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, CurrencyGroupSeparator e NumberGroupSeparator.
Confira também
- Parse(String)
- ToString()
- Analisando cadeias de caracteres numéricas no .NET
- Amostra: Utilitário de Formatação do WinForms do .NET Core (C#)
- Amostra: Utilitário de Formatação do WinForms do .NET Core (Visual Basic)
Aplica-se a
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)
- Origem:
- Double.cs
- Origem:
- Double.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] double % result) = IUtf8SpanParsable<double>::TryParse;
public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out double result);
static member TryParse : ReadOnlySpan<byte> * IFormatProvider * double -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Double) 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 à cultura sobre utf8Text
.
- result
- Double
No retorno, contém o resultado da análise utf8Text
com êxito ou de um valor indefinido em caso de falha.
Retornos
true
se utf8Text
foi analisado com êxito; caso contrário, false
.
Aplica-se a
TryParse(String, IFormatProvider, Double)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Tenta analisar uma cadeia de caracteres em um valor.
public:
static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = IParsable<double>::TryParse;
public static bool TryParse (string? s, IFormatProvider? provider, out double result);
static member TryParse : string * IFormatProvider * double -> bool
Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Double) 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 à cultura sobre s
.
- result
- Double
Quando este método retorna, contém o resultado da análise s
com êxito ou um valor indefinido em caso de falha.
Retornos
true
se s
foi analisado com êxito; caso contrário, false
.
Aplica-se a
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)
- Origem:
- Double.cs
- Origem:
- Double.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] double % result) = System::Numerics::INumberBase<double>::TryParse;
public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);
static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * double -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Double) 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 de número que podem estar presentes em utf8Text
.
- provider
- IFormatProvider
Um objeto que fornece informações de formatação específicas à cultura sobre utf8Text
.
- result
- Double
No retorno, contém o resultado da análise utf8Text
com êxito ou de um valor indefinido em caso de falha.
Retornos
true
se utf8Text
foi analisado com êxito; caso contrário, false
.
Aplica-se a
TryParse(ReadOnlySpan<Byte>, Double)
- Origem:
- Double.cs
- Origem:
- Double.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 dupla equivalente.
public:
static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] double % result);
public static bool TryParse (ReadOnlySpan<byte> utf8Text, out double result);
static member TryParse : ReadOnlySpan<byte> * double -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Double) 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
- Double
Quando este método retorna, contém um número de ponto flutuante de precisão dupla 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 falhará se o utf8Text
estiver Empty ou não estiver em um formato válido. Este parâmetro é passado não inicializado; qualquer valor fornecido originalmente no resultado será substituído.
Retornos
true
caso utf8Text
tenha sido convertido com êxito; do contrário, false
.
Aplica-se a
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte um intervalo de caracteres que contém a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla 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] double % result);
public:
static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out double result);
static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * double -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Double) As Boolean
Parâmetros
- s
- ReadOnlySpan<Char>
Um intervalo de caracteres somente leitura que contém o número a converter.
- style
- NumberStyles
Uma combinação bit a bit de valores de NumberStyles que indica o formato permitido de 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
.
- result
- Double
Quando esse método for retornado e se a conversão for bem-sucedida, ele conterá um número de ponto flutuante de precisão dupla equivalente ao valor numérico ou símbolo contido em s
. Conterá zero se a conversão falhar. A conversão falhará se o parâmetro s
for null
, um intervalo de caracteres vazio ou não for um número em um formato compatível com style
. Se s
for um número válido menor que Double.MinValue, result
será NegativeInfinity. Se s
for um número válido maior que Double.MaxValue, result
será PositiveInfinity. Este parâmetro é passado não inicializado; qualquer valor fornecido originalmente em result
será substituído.
Retornos
true
caso s
tenha sido convertido com êxito; do 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 resultava em falha.
Aplica-se a
TryParse(String, NumberStyles, IFormatProvider, Double)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla 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] double % result);
public:
static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;
public static bool TryParse (string s, System.Globalization.NumberStyles style, IFormatProvider provider, out double result);
public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);
static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * double -> bool
Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Double) As Boolean
Parâmetros
- s
- String
Uma cadeia de caracteres que contém um número a ser convertido.
- style
- NumberStyles
Uma combinação bit a bit de valores de NumberStyles que indica o formato permitido de s
. Um valor típico para ser especificado é uma combinação de Float com AllowThousands.
- provider
- IFormatProvider
Um IFormatProvider que fornece informações de formatação específica de cultura sobre s
.
- result
- Double
Quando esse método retorna, ele contém o número de ponto flutuante de precisão dupla equivalente ao valor numérico ou símbolo contido em s
, caso a conversão seja bem-sucedida, ou zero, caso a conversão falhe. A conversão falhará se o parâmetro s
for null
, Empty, se não estiver em um formato em conformidade com style
ou se style
não for uma combinação válida de constantes de enumeração de NumberStyles. Ele também falhará no .NET Framework ou no .NET Core 2.2 e em versões anteriores se s
representar um número menor que SByte.MinValue ou maior que SByte.MaxValue. Este parâmetro é passado não inicializado; qualquer valor fornecido originalmente em result
será substituído.
Retornos
true
caso s
tenha sido convertido com êxito; do contrário, false
.
Exceções
Exemplos
O exemplo a seguir demonstra o uso do Double.TryParse(String, NumberStyles, IFormatProvider, Double) método 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;
NumberStyles style;
CultureInfo culture;
double number;
// Parse currency value using en-GB culture.
value = "£1,097.63";
style = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
culture = CultureInfo.CreateSpecificCulture("en-GB");
if (Double.TryParse(value, style, culture, out number))
Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
// Converted '£1,097.63' to 1097.63.
value = "1345,978";
style = NumberStyles.AllowDecimalPoint;
culture = CultureInfo.CreateSpecificCulture("fr-FR");
if (Double.TryParse(value, style, culture, out number))
Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
// Converted '1345,978' to 1345.978.
value = "1.345,978";
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
culture = CultureInfo.CreateSpecificCulture("es-ES");
if (Double.TryParse(value, style, culture, out number))
Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
// Converted '1.345,978' to 1345.978.
value = "1 345,978";
if (Double.TryParse(value, style, culture, out number))
Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
// Unable to convert '1 345,978'.
// Parse currency value using en-GB culture.
let value = "£1,097.63"
let style = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
let culture = CultureInfo.CreateSpecificCulture "en-GB"
match Double.TryParse(value, style, culture) with
| true, number ->
printfn $"Converted '{value}' to {number}."
| _ ->
printfn $"Unable to convert '{value}'."
// Displays:
// Converted '£1,097.63' to 1097.63.
let value = "1345,978"
let style = NumberStyles.AllowDecimalPoint
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
match Double.TryParse(value, style, culture) with
| true, number ->
printfn $"Converted '{value}' to {number}."
| _ ->
printfn $"Unable to convert '{value}'."
// Displays:
// Converted '1345,978' to 1345.978.
let value = "1.345,978"
let style = NumberStyles.AllowDecimalPoint ||| NumberStyles.AllowThousands
let culture = CultureInfo.CreateSpecificCulture("es-ES")
match Double.TryParse(value, style, culture) with
| true, number ->
printfn $"Converted '{value}' to {number}."
| _ ->
printfn $"Unable to convert '{value}'."
// Displays:
// Converted '1.345,978' to 1345.978.
let value = "1 345,978"
match Double.TryParse(value, style, culture) with
| true, number ->
printfn $"Converted '{value}' to {number}."
| _ ->
printfn $"Unable to convert '{value}'."
// Displays:
// Unable to convert '1 345,978'.
Dim value As String
Dim style As NumberStyles
Dim culture As CultureInfo
Dim number As Double
' Parse currency value using en-GB culture.
value = "£1,097.63"
style = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
culture = CultureInfo.CreateSpecificCulture("en-GB")
If Double.TryParse(value, style, culture, number) Then
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
Console.WriteLine("Unable to convert '{0}'.", value)
End If
' Displays:
' Converted '£1,097.63' to 1097.63.
value = "1345,978"
style = NumberStyles.AllowDecimalPoint
culture = CultureInfo.CreateSpecificCulture("fr-FR")
If Double.TryParse(value, style, culture, number) Then
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
Console.WriteLine("Unable to convert '{0}'.", value)
End If
' Displays:
' Converted '1345,978' to 1345.978.
value = "1.345,978"
style = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands
culture = CultureInfo.CreateSpecificCulture("es-ES")
If Double.TryParse(value, style, culture, number) Then
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
Console.WriteLine("Unable to convert '{0}'.", value)
End If
' Displays:
' Converted '1.345,978' to 1345.978.
value = "1 345,978"
If Double.TryParse(value, style, culture, number) Then
Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
Console.WriteLine("Unable to convert '{0}'.", value)
End If
' Displays:
' 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 resultava em falha.
O TryParse método é como o Parse(String, NumberStyles, IFormatProvider) método , exceto que esse método não gera uma exceção se a conversão falhar. Se a conversão for bem-sucedida, o valor retornado será true
e o result
parâmetro será definido como o resultado da conversão. Se a conversão falhar, o valor retornado será false
e o result
parâmetro será definido como zero. Isso 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. 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 indicada por provider
. Além disso, dependendo do valor de style
, o s
parâmetro pode incluir os seguintes elementos:
[ws] [$] [sign] [integral-digits,]integral-digits[.fractional-digits][e[sign]exponential-digits][ws]
Os elementos entre 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 pode aparecer no início de s se style incluir o NumberStyles.AllowLeadingWhite sinalizador . Ele pode aparecer no final de s se style incluir o NumberStyles.AllowTrailingWhite sinalizador . |
$ | Um símbolo de moeda específico de cultura. Sua posição na cadeia de caracteres é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades ou NumberFormatInfo.CurrencyPositivePattern do NumberFormatInfo objeto retornado pelo IFormatProvider.GetFormat método do provider parâmetro . O símbolo de moeda pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol. |
sign | Um sinal opcional. 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. Os dígitos integrais podem estar ausentes caso sejam dígitos fracionários. |
, | Um símbolo de separador de milhares 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 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 s pode representar um número usando notação exponencial. O s parâmetro poderá representar um número na notação exponencial se o estilo incluir o NumberStyles.AllowExponent sinalizador. |
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) 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 Double êxito. Os membros restantes System.Globalization.NumberStyles controlam elementos que podem ser, mas 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 . e 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 de dígitos integraisEexponencial-digits; 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 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 , . |
AllowCurrencySymbol | O $ elemento . |
Currency | Todos. O parâmetro 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 s e no símbolo . O parâmetro s também pode usar notação exponencial. |
Number | Os ws elementos separador , sign , milhares (,) e ponto decimal (.). |
Any | Todos os estilos, exceto caso s não possa representar um número hexadecimal. |
O provider
parâmetro é uma IFormatProvider implementação, como um NumberFormatInfo objeto ou CultureInfo . O parâmetro provider
fornece informações específicas da cultura usadas na análise. Se provider
for null
ou um NumberFormatInfo objeto não puder ser obtido, as informações de formato da cultura atual serão usadas.
A conversão falhará se o s
parâmetro for null
ou não um valor numérico, o provider
parâmetro não produzirá um NumberFormatInfo objeto ou o style
parâmetro não for uma combinação de sinalizadores de bits da NumberStyles enumeração.
Normalmente, se você passa ao método Double.TryParse, uma cadeia de caracteres criada chamando-se o método Double.ToString, o valor Double original é retornado. No entanto, por conta de uma perda de precisão, os valores talvez não sejam iguais. Além disso, tentar analisar a representação de cadeia de caracteres de Double.MinValue ou falha na viagem de ida e Double.MaxValue volta. No .NET Framework e no .NET Core 2.2 e nas versões anteriores, ele lança um OverflowException. No .NET Core 3.0 e versões posteriores, ele retornará Double.NegativeInfinity se você tentar analisar MinValue ou Double.PositiveInfinity se tentar analisar MaxValue. O exemplo a seguir ilustra esse cenário.
using System;
public class Example
{
public static void Main()
{
string value;
double number;
value = Double.MinValue.ToString();
if (Double.TryParse(value, out number))
Console.WriteLine(number);
else
Console.WriteLine("{0} is outside the range of a Double.",
value);
value = Double.MaxValue.ToString();
if (Double.TryParse(value, out number))
Console.WriteLine(number);
else
Console.WriteLine("{0} is outside the range of a Double.",
value);
}
}
// The example displays the following output:
// -1.79769313486232E+308 is outside the range of the Double type.
// 1.79769313486232E+308 is outside the range of the Double type.
open System
[<EntryPoint>]
let main _ =
let value = string Double.MinValue
match Double.TryParse value with
| true, number ->
printfn $"{number}"
| _ ->
printfn $"{value} is outside the range of a Double."
let value = string Double.MaxValue
match Double.TryParse value with
| true, number ->
printfn $"{number}"
| _ ->
printfn $"{value} is outside the range of a Double."
0
// The example displays the following output:
// -1.79769313486232E+308 is outside the range of the Double type.
// 1.79769313486232E+308 is outside the range of the Double type.
Module Example
Public Sub Main()
Dim value As String
Dim number As Double
value = Double.MinValue.ToString()
If Double.TryParse(value, number) Then
Console.WriteLine(number)
Else
Console.WriteLine("{0} is outside the range of a Double.", _
value)
End If
value = Double.MaxValue.ToString()
If Double.TryParse(value, number) Then
Console.WriteLine(number)
Else
Console.WriteLine("{0} is outside the range of a Double.", _
value)
End If
End Sub
End Module
' The example displays the following output:
' -1.79769313486232E+308 is outside the range of the Double type.
' 1.79769313486232E+308 is outside the range of the Double type.
No .NET Framework e no .NET Core 2.2 e versões anteriores, se s
estiver fora do intervalo do tipo de Double dados, o Double.TryParse(String, NumberStyles, IFormatProvider, Double) método gerará um OverflowException.
No .NET Core 3.0 e versões posteriores, nenhuma exceção é gerada quando s
está fora do intervalo do tipo de Double dados. Na maioria dos casos, o Double.TryParse(String, NumberStyles, IFormatProvider, Double) método calcula um resultado de Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, há um pequeno conjunto de valores que são considerados mais próximos dos valores máximo ou mínimo de Double do que para infinito positivo ou negativo. Nesses casos, o método calcula um resultado de Double.MaxValue ou Double.MinValue.
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
Comentários
https://aka.ms/ContentUserFeedback.
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja:Submeter e ver comentários