Double.TryParse Método

Definição

Namespace:: System

Assemblies:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assemblies:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

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 de cadeia de caracteres de um número em seu equivalente de número de ponto flutuante de precisão dupla. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

Sobrecargas

Nome	Description
TryParse(String, IFormatProvider, Double)	Tenta analisar uma cadeia 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 especificado em seu 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 de cadeia de caracteres de um número em seu equivalente de 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(ReadOnlySpan<Char>, IFormatProvider, Double)	Tenta analisar um intervalo 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 especificado em seu 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 especificado em seu 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 posterior, 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(String, IFormatProvider, Double)

Origem:: Double.cs

Origem:: Double.cs

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

result: Double

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

Retornos

Boolean

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

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 especificado em seu 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 ser convertido.

result: Double

Quando esse método retorna, contém o número de ponto flutuante de precisão dupla equivalente do valor numérico ou símbolo contido no s parâmetro, se a conversão tiver sido bem-sucedida ou zero se a conversão falhar. A conversão falhará se o s parâmetro estiver null ou vazio. 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. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido result será substituído.

Retornos

Boolean

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

Comentários

Aplica-se a

TryParse(String, Double)

Origem:: Double.cs

Origem:: Double.cs

Origem:: Double.cs

Origem:: Double.cs

Origem:: Double.cs

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 número de ponto flutuante de precisão dupla equivalente do s parâmetro, se a conversão foi bem-sucedida ou zero se a conversão falhou. A conversão falhará se o s parâmetro for null ou Empty não for um número em um formato válido. Ele também falhará no .NET Framework se s representar um número menor que Double.MinValue ou maior que Double.MaxValue. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido result será substituído.

Retornos

Boolean

true se s tiver sido convertido com êxito; caso 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

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. 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 s parâmetro pode conter o símbolo ou NumberFormatInfo.PositiveInfinitySymbol a cultura NumberFormatInfo.NegativeInfinitySymbol NumberFormatInfo.NaNSymbolatual. Essa comparação de cadeia de caracteres não diferencia maiúsculas de minúsculas no .NET Core 3.0 e versões posteriores, mas diferencia maiúsculas de minúsculas em versões anteriores, incluindo o .NET Framework. O s parâmetro também pode ser 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.
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.
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 exponencial	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 de sinalizadores e NumberStyles.Float sinalizadoresNumberStyles.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 sbranco) que podem estar presentes, use a sobrecarga do Double.TryParse(String, NumberStyles, IFormatProvider, Double) método.

O s parâmetro é analisado usando as informações de formatação em um NumberFormatInfo objeto 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 Double.TryParse(String, NumberStyles, IFormatProvider, Double) método.

Normalmente, se você passar ao Double.TryParse método uma cadeia de caracteres criada chamando o Double.ToString método, o valor original Double será retornado. No entanto, devido a uma perda de precisão, os valores podem não ser iguais. Além disso, a tentativa de analisar a representação de cadeia de caracteres de uma Double.MinValue ou outra falha na viagem de ida e Double.MaxValue volta. No .NET Framework, ele lança um OverflowException. No .NET Core 3.0 e versões posteriores, ele retornará Double.NegativeInfinity se você tentar analisar MinValueou Double.PositiveInfinity se tentar analisar MaxValue. O exemplo a seguir fornece uma ilustração.

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, 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 do Double que do 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 de grupo e decimal 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, NumberDecimalSeparatore CurrencyGroupSeparator NumberGroupSeparator.

Confira também

Aplica-se a

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)

Origem:: Double.cs

Origem:: Double.cs

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

result: Double

No retorno, contém o resultado da análise utf8Text com êxito ou de um valor indefinido sobre a falha.

Retornos

Boolean

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

Aplica-se a

TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)

Origem:: Double.cs

Origem:: Double.cs

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

result: Double

Quando esse método é retornado, contém o resultado da análise scom êxito ou um valor indefinido sobre a falha.

Retornos

Boolean

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

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 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: Double

No retorno, contém o resultado da análise utf8Text com êxito ou de um valor indefinido sobre a falha.

Retornos

Boolean

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

Aplica-se a

TryParse(ReadOnlySpan<Byte>, Double)

Origem:: Double.cs

Origem:: Double.cs

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 esse método retorna, contém um número de ponto flutuante de precisão dupla equivalente ao valor numérico ou símbolo contido se utf8Text a conversão tiver sido bem-sucedida ou zero se a conversão falhar. A conversão falhará se estiver utf8TextEmpty 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 tiver sido convertido com êxito; caso contrário, false.

Aplica-se a

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

Origem:: Double.cs

Origem:: Double.cs

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 especificado em seu 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) = System::Numerics::INumberBase<double>::TryParse;

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, 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 ser convertido.

style: NumberStyles

Uma combinação bit a bit de NumberStyles valores 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: Double

Quando esse método retorna e se a conversão foi bem-sucedida, contém um número de ponto flutuante de precisão dupla equivalente ao valor numérico ou símbolo contido em s. Contém zero se a conversão falhou. A conversão falhará se o s parâmetro for null, um intervalo de caracteres vazio ou não 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. Esse parâmetro é passado sem inicialização; qualquer valor originalmente fornecido result será substituído.

Retornos

Boolean

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

Comentários

Aplica-se a

TryParse(String, NumberStyles, IFormatProvider, Double)

Origem:: Double.cs

Origem:: Double.cs

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 especificado em seu 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 NumberStyles valores que indica o formato permitido de s. Um valor típico a ser especificado é Float combinado com AllowThousands.

provider: IFormatProvider

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

result: Double

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

Retornos

Boolean

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

Exceções

ArgumentException

style não é um NumberStyles valor.

-ou-

style inclui o AllowHexSpecifier valor.

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

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ção para testar um FormatException caso s seja inválido e não possa ser analisado com êxito.

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

O s parâmetro pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolou NumberFormatInfo.NaNSymbol símbolo para a cultura indicada por provider. Essa comparação de cadeia de caracteres não diferencia maiúsculas de minúsculas no .NET Core 3.0 e versões posteriores, mas diferencia maiúsculas de 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] [$] [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 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 à cultura. Sua posição na cadeia de caracteres é definida pelas NumberFormatInfo.CurrencyNegativePattern propriedades ou NumberFormatInfo.CurrencyPositivePattern NumberFormatInfo pelo objeto retornado pelo IFormatProvider.GetFormat método do `provider` parâmetro. O símbolo de moeda poderá aparecer `s` se `style` incluir o NumberStyles.AllowCurrencySymbol sinalizador.
assinar	Um sinal opcional. O sinal pode aparecer no início de `s` se incluir o `style` sinalizador e pode aparecer no final de NumberStyles.AllowLeadingSign se `s` incluir o `style`NumberStyles.AllowTrailingSign sinalizador. Parênteses podem ser usados `s` para indicar um valor negativo se `style` incluir o NumberStyles.AllowParentheses sinalizador.
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 poderá aparecer `s` se `style` incluir o NumberStyles.AllowThousands sinalizador.
.	Um símbolo de ponto decimal específico da cultura. O símbolo de ponto decimal da cultura atual poderá aparecer `s` se `style` incluir o NumberStyles.AllowDecimalPoint sinalizador.
dígitos fracionários	Uma série de dígitos que variam de 0 a 9 que especificam a parte fracionária do número. Os dígitos fracionários poderão `s` aparecer se `style` incluir o NumberStyles.AllowDecimalPoint sinalizador.
e	O caractere 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 na notação exponencial se o estilo incluir o NumberStyles.AllowExponent sinalizador.
dígitos exponencial	Uma série de dígitos que variam de 0 a 9 que especificam um expoente.

Nota

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

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

Valor de 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 `s` parâmetro também pode usar notação exponencial. Esse sinalizador por si só dá suporte a valores na forma de dígitos integraisEexponencial-dígitos; 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 sign no início de `s`.
AllowTrailingSign	O elemento sign no final de `s`.
AllowParentheses	O elemento sign na forma de parênteses que inclui o valor numérico.
AllowThousands	O elemento .
AllowCurrencySymbol	O $ elemento.
Currency	Todo. 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 no final de `s`, assinar no início e `s`o símbolo . O `s` parâmetro também pode usar notação exponencial.
Number	Os `ws`elementos separador , `sign`milhares (,) 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, como um objeto ou NumberFormatInfo um CultureInfo objeto. O provider parâmetro 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 se o style parâmetro não for uma combinação de sinalizadores de bits da NumberStyles enumeração.

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, 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 Double tipo de 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áximos ou mínimos do Double que do 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 a moeda ou número decimais aplicáveis e separadores de grupo forem iguais, 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, NumberDecimalSeparatore CurrencyGroupSeparator NumberGroupSeparator.

Confira também

Aplica-se a

Comentários

Esta página foi útil?

Partilhar via

Double.TryParse Método

Definição

Sobrecargas

Comentários

TryParse(String, IFormatProvider, Double)

Parâmetros

Retornos

Aplica-se a

TryParse(ReadOnlySpan<Char>, Double)

Parâmetros

Retornos

Comentários

Aplica-se a

TryParse(String, Double)

Parâmetros

Retornos

Exemplos

Comentários

Confira também

Aplica-se a

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)

Parâmetros

Retornos

Aplica-se a

TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)

Parâmetros

Retornos

Aplica-se a

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

Parâmetros

Retornos

Aplica-se a

TryParse(ReadOnlySpan<Byte>, Double)

Parâmetros

Retornos

Aplica-se a

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

Parâmetros

Retornos

Comentários

Aplica-se a

TryParse(String, NumberStyles, IFormatProvider, Double)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Comentários