Double.TryParse Método

Source:

Double.cs

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si s se ha analizado correctamente; de lo contrario, false.

Source:

Double.cs

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si s se convirtió correctamente; de lo contrario, false.

Comentarios

En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

Source:

Double.cs

Source:

Double.cs

Source:

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

Devoluciones

true si s se convirtió correctamente; de lo contrario, false.

Ejemplos

En el ejemplo siguiente se usa el método TryParse(String, Double) para convertir las representaciones de cadena de valores numéricos en Double valores. Se supone que en-US es la referencia cultural actual.

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

Comentarios

En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

Esta sobrecarga difiere del método Double.Parse(String) devolviendo un valor booleano que indica si la operación de análisis se realizó correctamente en lugar de devolver el valor numérico analizado. Elimina la necesidad de usar el control de excepciones para probar un FormatException en caso de que s no sea válido y no se pueda analizar correctamente.

El parámetro s puede contener la referencia cultural actual NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.NaNSymbol (la comparación de cadenas distingue mayúsculas de minúsculas) o una cadena del formulario:

[ws] [sign] [entero-digits,]integral-digits[.[ fracciones-dígitos]][e[sign]exponencial-digits][ws]

Los elementos entre corchetes son opcionales. En la tabla siguiente se describe cada elemento.

Para obtener más información sobre los formatos numéricos, vea Tipos de formato.

El parámetro s se interpreta mediante una combinación de las marcas NumberStyles.Float y NumberStyles.AllowThousands. Esto significa que se permiten espacios en blanco y separadores de miles, pero no se permiten símbolos de moneda. Para definir explícitamente los elementos (como símbolos de moneda, separadores de miles y espacios en blanco) que pueden estar presentes en s, use la sobrecarga del método Double.TryParse(String, NumberStyles, IFormatProvider, Double).

El parámetro s se analiza mediante la información de formato de un objeto NumberFormatInfo que se inicializa para la referencia cultural del sistema actual. Para obtener más información, consulte NumberFormatInfo.CurrentInfo. Para analizar una cadena mediante la información de formato de alguna otra referencia cultural especificada, use la sobrecarga del método Double.TryParse(String, NumberStyles, IFormatProvider, Double).

Normalmente, si pasa el método Double.TryParse una cadena que se crea llamando al método Double.ToString, se devuelve el valor de Double original. Sin embargo, debido a una pérdida de precisión, es posible que los valores no sean iguales. Además, al intentar analizar la representación de cadena de Double.MinValue o Double.MaxValue no se puede realizar un recorrido de ida y vuelta. En .NET Framework y .NET Core 2.2 y versiones anteriores, produce una OverflowException. En .NET Core 3.0 y versiones posteriores, devuelve Double.NegativeInfinity si intenta analizar MinValue o Double.PositiveInfinity si intenta analizar MaxValue. En el ejemplo siguiente se proporciona una ilustración.

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.

En .NET Framework y .NET Core 2.2 y versiones anteriores, si s está fuera del intervalo del tipo de datos Double, el método TryParse(String, Double) produce un OverflowException.

En .NET Core 3.0 y versiones posteriores, no se produce ninguna excepción cuando s está fuera del intervalo del tipo de datos Double. En la mayoría de los casos, el método TryParse(String, Double) calcula un resultado de Double.PositiveInfinity o Double.NegativeInfinity. Sin embargo, hay un pequeño conjunto de valores que se consideran más cercanos a los valores máximos o mínimos de Double que a infinito positivo o negativo. En esos casos, el método calcula un resultado de Double.MaxValue o Double.MinValue.

Si se encuentra un separador en el parámetro s durante una operación de análisis y los separadores decimales y de grupo son los mismos, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.

Consulte también

• Parse(String)
• ToString()
• analizar cadenas numéricas en .NET
• ejemplo: Utilidad de formato winForms de .NET Core (C#)
• ejemplo: Utilidad de formato winForms de .NET Core (Visual Basic)

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si utf8Text se ha analizado correctamente; de lo contrario, false.

Source:

Double.cs

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si s se ha analizado correctamente; de lo contrario, false.

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si utf8Text se ha analizado correctamente; de lo contrario, false.

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si utf8Text se convirtió correctamente; de lo contrario, false.

Source:

Double.cs

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si s se convirtió correctamente; de lo contrario, false.

Comentarios

En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

Source:

Double.cs

Source:

Double.cs

Source:

Double.cs

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

Devoluciones

true si s se convirtió correctamente; de lo contrario, false.

Excepciones

Ejemplos

En el ejemplo siguiente se muestra el uso del método Double.TryParse(String, NumberStyles, IFormatProvider, Double) para analizar la representación de cadena de números que tienen un estilo determinado y se da formato a las convenciones de una referencia cultural determinada.

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

Comentarios

En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

El método TryParse es similar al método Parse(String, NumberStyles, IFormatProvider), salvo que este método no produce una excepción si se produce un error en la conversión. Si la conversión se realiza correctamente, el valor devuelto se true y el parámetro result se establece en el resultado de la conversión. Si se produce un error en la conversión, el valor devuelto es false y el parámetro result se establece en cero. Esto elimina la necesidad de usar el control de excepciones para probar un FormatException en caso de que s no sea válido y no se pueda analizar correctamente.

El parámetro style define el formato permitido del parámetro s para que la operación de análisis se realice correctamente. Debe ser una combinación de marcas de bits de la enumeración NumberStyles. No se admiten los siguientes miembros de NumberStyles:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

El parámetro s puede contener NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol para la referencia cultural indicada por provider. Además, dependiendo del valor de style, el parámetro s puede incluir los siguientes elementos:

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

Los elementos entre corchetes ([ y ]) son opcionales. En la tabla siguiente se describe cada elemento.

Una cadena solo con dígitos (que corresponde al estilo NumberStyles.None) siempre analiza correctamente si está en el intervalo del tipo Double. Los miembros de System.Globalization.NumberStyles restantes controlan los elementos que pueden estar presentes, pero no deben estar presentes en la cadena de entrada. En la tabla siguiente se indica cómo afectan las marcas de NumberStyles individuales a los elementos que pueden estar presentes en s.

El parámetro provider es una implementación de IFormatProvider, como un objeto NumberFormatInfo o CultureInfo. El parámetro provider proporciona información específica de la referencia cultural que se usa en el análisis. Si provider es null o no se puede obtener un objeto NumberFormatInfo, se usa la información de formato de la referencia cultural actual.

Se produce un error en la conversión si el parámetro s es null o no un valor numérico, el parámetro provider no produce un objeto NumberFormatInfo o el parámetro style no es una combinación de marcas de bits de la enumeración NumberStyles.

Normalmente, si pasa el método Double.TryParse una cadena que se crea llamando al método Double.ToString, se devuelve el valor de Double original. Sin embargo, debido a una pérdida de precisión, es posible que los valores no sean iguales. Además, al intentar analizar la representación de cadena de Double.MinValue o Double.MaxValue no se puede realizar un recorrido de ida y vuelta. En .NET Framework y .NET Core 2.2 y versiones anteriores, produce una OverflowException. En .NET Core 3.0 y versiones posteriores, devuelve Double.NegativeInfinity si intenta analizar MinValue o Double.PositiveInfinity si intenta analizar MaxValue. En el ejemplo siguiente se proporciona una ilustración.

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.

En .NET Framework y .NET Core 2.2 y versiones anteriores, si s está fuera del intervalo del tipo de datos Double, el método Double.TryParse(String, NumberStyles, IFormatProvider, Double) produce un OverflowException.

En .NET Core 3.0 y versiones posteriores, no se produce ninguna excepción cuando s está fuera del intervalo del tipo de datos Double. En la mayoría de los casos, el método Double.TryParse(String, NumberStyles, IFormatProvider, Double) calcula un resultado de Double.PositiveInfinity o Double.NegativeInfinity. Sin embargo, hay un pequeño conjunto de valores que se consideran más cercanos a los valores máximos o mínimos de Double que a infinito positivo o negativo. En esos casos, el método calcula un resultado de Double.MaxValue o Double.MinValue.

Si se encuentra un separador en el parámetro s durante una operación de análisis y los separadores decimales y de grupo aplicables son los mismos, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.

Consulte también

• ToString()
• analizar cadenas numéricas en .NET