Double.Parse Método

Definición

Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión doble equivalente.

Sobrecargas

Parse(String, NumberStyles, IFormatProvider)

Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión doble equivalente.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convierte un intervalo de caracteres que contiene la representación en cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en el número de punto flotante de precisión doble equivalente.

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analiza un intervalo de caracteres UTF-8 en un valor.

Parse(String, IFormatProvider)

Convierte la representación en forma de cadena de un número con un formato específico de la referencia cultural especificado en el número de punto flotante de precisión doble equivalente.

Parse(String)

Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión doble equivalente.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analiza un intervalo de caracteres en un valor.

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Analiza un intervalo de caracteres UTF-8 en un valor.

Parse(String, NumberStyles)

Convierte la representación en forma de cadena de un número con un estilo especificado en el número de punto flotante de precisión doble equivalente.

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 lo requiera 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.

Parse(String, NumberStyles, IFormatProvider)

Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión doble equivalente.

public:
 static double Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
 static double Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<double>::Parse;
public static double Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static double Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> double
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Double

Parámetros

s
String

Cadena que contiene un número que se va a convertir.

style
NumberStyles

Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s. Un valor que se especifica de forma habitual es Float combinado con AllowThousands.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

Devoluciones

Número de punto flotante de precisión doble equivalente al valor numérico o símbolo especificado en s.

Implementaciones

Excepciones

s no representa un valor numérico.

style no es un valor NumberStyles.

O bien

style es el valor AllowHexSpecifier.

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que Double.MinValue o mayor que Double.MaxValue.

Ejemplos

En el Parse(String, NumberStyles, IFormatProvider) ejemplo siguiente se muestra el uso del método para asignar varias representaciones de cadena de valores de temperatura a un Temperature objeto .

using System;
using System.Globalization;

public class Temperature
{
   // Parses the temperature from a string. Temperature scale is
   // indicated by 'F (for Fahrenheit) or 'C (for Celsius) at the end
   // of the string.
   public static Temperature Parse(string s, NumberStyles styles,
                                   IFormatProvider provider)
   {
      Temperature temp = new Temperature();

      if (s.TrimEnd(null).EndsWith("'F"))
      {
         temp.Value = Double.Parse(s.Remove(s.LastIndexOf((char)39), 2),
                                   styles, provider);
      }
      else
      {
         if (s.TrimEnd(null).EndsWith("'C"))
            temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf((char)39), 2),
                                        styles, provider);
         else
            temp.Value = Double.Parse(s, styles, provider);
      }
      return temp;
   }

   // Declare private constructor so Temperature so only Parse method can
   // create a new instance
   private Temperature()   {}

   protected double m_value;

   public double Value
   {
      get { return m_value; }
      private set { m_value = value; }
   }

   public double Celsius
   {
      get { return (m_value - 32) / 1.8; }
      private set { m_value = value * 1.8 + 32; }
   }

   public double Fahrenheit
   {
      get {return m_value; }
   }
}

public class TestTemperature
{
   public static void Main()
   {
      string value;
      NumberStyles styles;
      IFormatProvider provider;
      Temperature temp;

      value = "25,3'C";
      styles = NumberStyles.Float;
      provider = CultureInfo.CreateSpecificCulture("fr-FR");
      temp = Temperature.Parse(value, styles, provider);
      Console.WriteLine("{0} degrees Fahrenheit equals {1} degrees Celsius.",
                        temp.Fahrenheit, temp.Celsius);

      value = " (40) 'C";
      styles = NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite
               | NumberStyles.AllowParentheses;
      provider = NumberFormatInfo.InvariantInfo;
      temp = Temperature.Parse(value, styles, provider);
      Console.WriteLine("{0} degrees Fahrenheit equals {1} degrees Celsius.",
                        temp.Fahrenheit, temp.Celsius);

      value = "5,778E03'C";      // Approximate surface temperature of the Sun
      styles = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands |
               NumberStyles.AllowExponent;
      provider = CultureInfo.CreateSpecificCulture("en-GB");
      temp = Temperature.Parse(value, styles, provider);
      Console.WriteLine("{0} degrees Fahrenheit equals {1} degrees Celsius.",
                        temp.Fahrenheit.ToString("N"), temp.Celsius.ToString("N"));
   }
}
open System
open System.Globalization

// Declare private constructor so Temperature so only Parse method can create a new instance
type Temperature private () =

    let mutable m_value = 0.

    member _.Value
        with get () = m_value
        and private set (value) = m_value <- value

    member _.Celsius
        with get() = (m_value - 32.) / 1.8
        and private set (value) = m_value <- value * 1.8 + 32.

    member _.Fahrenheit =
        m_value

    // Parses the temperature from a string. Temperature scale is
    // indicated by 'F (for Fahrenheit) or 'C (for Celsius) at the end
    // of the string.
    static member Parse(s: string, styles: NumberStyles, provider: IFormatProvider) =
        let temp = new Temperature()

        if s.TrimEnd(null).EndsWith "'F" then
            temp.Value <- Double.Parse(s.Remove(s.LastIndexOf(char 39), 2), styles, provider)
        else
            if s.TrimEnd(null).EndsWith "'C" then
                temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf(char 39), 2), styles, provider)
            else
                temp.Value <- Double.Parse(s, styles, provider)
        temp

[<EntryPoint>]
let main _ =
    let value = "25,3'C"
    let styles = NumberStyles.Float
    let provider = CultureInfo.CreateSpecificCulture "fr-FR"
    let temp = Temperature.Parse(value, styles, provider)
    printfn $"{temp.Fahrenheit} degrees Fahrenheit equals {temp.Celsius} degrees Celsius."

    let value = " (40) 'C"
    let styles = NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite ||| NumberStyles.AllowParentheses
    let provider = NumberFormatInfo.InvariantInfo
    let temp = Temperature.Parse(value, styles, provider)
    printfn $"{temp.Fahrenheit} degrees Fahrenheit equals {temp.Celsius} degrees Celsius."

    let value = "5,778E03'C"      // Approximate surface temperature of the Sun
    let styles = NumberStyles.AllowDecimalPoint ||| NumberStyles.AllowThousands ||| NumberStyles.AllowExponent
    let provider = CultureInfo.CreateSpecificCulture "en-GB"
    let temp = Temperature.Parse(value, styles, provider)
    printfn $"{temp.Fahrenheit:N} degrees Fahrenheit equals {temp.Celsius:N} degrees Celsius."

    0
Imports System.Globalization

Public Class Temperature
   ' Parses the temperature from a string. Temperature scale is 
   ' indicated by 'F (for Fahrenheit) or 'C (for Celsius) at the end
   ' of the string.
   Public Shared Function Parse(s As String, styles As NumberStyles, _
                                provider As IFormatProvider) As Temperature
      Dim temp As New Temperature()
      
      If s.TrimEnd(Nothing).EndsWith("'F") Then
         temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), _
                                   styles, provider)
      Else
         If s.TrimEnd(Nothing).EndsWith("'C") Then
            temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), _
                                        styles, provider)
         Else
            temp.Value = Double.Parse(s, styles, provider)         
         End If
      End If
      Return temp      
   End Function 
   
   ' Declare private constructor so Temperature so only Parse method can
   ' create a new instance
   Private Sub New 
   End Sub

   Protected m_value As Double
   
   Public Property Value() As Double
      Get
         Return m_value
      End Get
      
      Private Set
         m_value = Value
      End Set
   End Property
   
   Public Property Celsius() As Double
      Get
         Return (m_value - 32) / 1.8
      End Get
      Private Set
         m_value = Value * 1.8 + 32
      End Set
   End Property
   
   Public ReadOnly Property Fahrenheit() As Double
      Get
         Return m_Value
      End Get   
   End Property   
End Class

Public Module TestTemperature
   Public Sub Main
      Dim value As String
      Dim styles As NumberStyles
      Dim provider As IFormatProvider
      Dim temp As Temperature
      
      value = "25,3'C"
      styles = NumberStyles.Float
      provider = CultureInfo.CreateSpecificCulture("fr-FR")
      temp = Temperature.Parse(value, styles, provider)
      Console.WriteLine("{0} degrees Fahrenheit equals {1} degrees Celsius.", _
                        temp.Fahrenheit, temp.Celsius)
      
      value = " (40) 'C"
      styles = NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite _
               Or NumberStyles.AllowParentheses
      provider = NumberFormatInfo.InvariantInfo
      temp = Temperature.Parse(value, styles, provider)
      Console.WriteLine("{0} degrees Fahrenheit equals {1} degrees Celsius.", _
                        temp.Fahrenheit, temp.Celsius)
      
      value = "5,778E03'C"      ' Approximate surface temperature of the Sun
      styles = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands Or _
               NumberStyles.AllowExponent
      provider = CultureInfo.CreateSpecificCulture("en-GB") 
      temp = Temperature.Parse(value, styles, provider)
      Console.WriteLine("{0} degrees Fahrenheit equals {1} degrees Celsius.", _
                        temp.Fahrenheit.ToString("N"), temp.Celsius.ToString("N"))
                                
   End Sub
End Module

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 lo requiera 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 style parámetro define los elementos de estilo (como espacios en blanco, separadores de miles y símbolos de moneda) que se permiten en el s parámetro para que la operación de análisis se realice correctamente. Debe ser una combinación de marcas de bits de la NumberStyles enumeración. No se admiten los siguientes NumberStyles miembros:

El s parámetro puede contener NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol para la referencia cultural especificada por provider. Dependiendo del valor de style, también puede tomar la forma:

[ws] [] [$sign][integral-digits,]integral-digits[.[ fracciones de dígitos]] [E[sign]exponencial-digits] [ws]

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

Elemento Descripción
ws Una serie de caracteres de espacio en blanco. El espacio en blanco puede aparecer al principio de s si incluye la NumberStyles.AllowLeadingWhite marca y puede aparecer al final de s si style incluye la NumberStyles.AllowTrailingWhitestyle marca.
$ Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las NumberFormatInfo.CurrencyNegativePattern propiedades y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural actual. El símbolo de moneda de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowCurrencySymbol marca .
sign Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). El signo puede aparecer al principio de s si incluye la NumberStyles.AllowLeadingSign marca y puede aparecer al final de s si style incluye la NumberStyles.AllowTrailingSignstyle marca. Los paréntesis se pueden usar en s para indicar un valor negativo si style incluye la NumberStyles.AllowParentheses marca .
dígitos enteros Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fracciones de dígitos .
, Separador de grupo específico de la referencia cultural. El símbolo separador de grupo de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowThousands marca .
. Símbolo de separador decimal específico de la referencia cultural. El símbolo de separador decimal de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowDecimalPoint marca .
fracciones de dígitos Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número. Los dígitos fraccionarios pueden aparecer en s si style incluye la NumberStyles.AllowDecimalPoint marca .
E El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El s parámetro puede representar un número en notación exponencial si style incluye la NumberStyles.AllowExponent marca .
dígitos exponenciales Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente.

Nota

La operación de análisis omite todos los caracteres NUL (U+0000) de s , independientemente del valor del style argumento.

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

Valor NumberStyles Elementos permitidos además s de dígitos
None Solo el elemento integral-digits .
AllowDecimalPoint Elementos decimales (.) y fracciones de dígitos .
AllowExponent El carácter "e" o "E", que indica la notación exponencial. Esta marca por sí misma admite valores en los dígitosde formaE digits; se necesitan marcas adicionales para analizar correctamente cadenas con elementos como signos positivos o negativos y símbolos decimales.
AllowLeadingWhite Elemento ws al principio de s.
AllowTrailingWhite Elemento ws al final de s.
AllowLeadingSign Elemento sign al principio de s.
AllowTrailingSign Elemento sign al final de s.
AllowParentheses Elemento de signo en forma de paréntesis que incluye el valor numérico.
AllowThousands Elemento separador de miles (,).
AllowCurrencySymbol Elemento currency ($).
Currency Todos los elementos. Sin embargo, s no puede representar un número hexadecimal o un número en notación exponencial.
Float Elemento ws al principio o al final de s, signo al principio de sy el símbolo decimal (.). El s parámetro también puede usar la notación exponencial.
Number Los wselementos separadores , sign, miles (,) y decimal point (.).
Any Todos los elementos. Sin embargo, s no puede representar un número hexadecimal.

El provider parámetro es una IFormatProvider implementación cuyo GetFormat método devuelve un NumberFormatInfo objeto que proporciona información específica de la referencia cultural utilizada para interpretar el formato de s. Normalmente, es un NumberFormatInfo objeto o CultureInfo . Si provider es null o NumberFormatInfo no se puede obtener, se usa la información de formato de la referencia cultural del sistema actual.

Normalmente, si pasa el Double.Parse método una cadena que se crea llamando al Double.ToString método , se devuelve el valor original Double . 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 o MinValue no se puede realizar un recorrido de ida y Double.MaxValue vuelta. En .NET Framework y .NET Core 2.2 y versiones anteriores, inicia una OverflowExceptionexcepción . En .NET Core 3.0 y versiones posteriores, devuelve Double.NegativeInfinity si intenta analizar MinValue o Double.PositiveInfinity si intenta analizar MaxValue. Esto se muestra en el ejemplo siguiente.

   string value;

   value = Double.MinValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   value = Double.MaxValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   // Format without the default precision.
   value = Double.MinValue.ToString("G17");
   try
   {
       Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException)
   {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }
// 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.
//    -1.79769313486232E+308
open System

[<EntryPoint>]
let main _ =
    let value = string Double.MinValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    let value = string Double.MaxValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    // Format without the default precision.
    let value = Double.MinValue.ToString "G17"
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    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.
//    -1.79769313486232E+308
Dim value As String

value = Double.MinValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

value = Double.MaxValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

' Format without the default precision.
value = Double.MinValue.ToString("G17")
Try 
    Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try
' 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.            
'    -1.79769313486232E+308

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

En .NET Core 3.0 y versiones posteriores, no se produce ninguna excepción cuando s está fuera del intervalo del Double tipo de datos. En la mayoría de los casos, el Parse(String, NumberStyles, IFormatProvider) método devolverá 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 son infinitos positivos o negativos. En esos casos, el método devuelve Double.MaxValue o Double.MinValue.

Si se encuentra un separador en el s parámetro durante una operación de análisis y los separadores decimales y de grupo aplicables son iguales, 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

Se aplica a

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convierte un intervalo de caracteres que contiene la representación en cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en el número de punto flotante de precisión doble equivalente.

public static double Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);
public static double Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> double
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, Optional provider As IFormatProvider = Nothing) As Double

Parámetros

s
ReadOnlySpan<Char>

Un intervalo de caracteres que contiene el número que se va a convertir.

style
NumberStyles

Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s. Un valor que se especifica de forma habitual es Float combinado con AllowThousands.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

Devoluciones

Número de punto flotante de precisión doble equivalente al valor numérico o símbolo especificado en s.

Implementaciones

Excepciones

s no representa un valor numérico.

style no es un valor NumberStyles.

O bien

style es el valor AllowHexSpecifier.

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 lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, analizar un valor demasiado grande para representar se produjo un error.

Si s está fuera del intervalo del Double tipo de datos, el método devuelve Double.NegativeInfinity si s es menor que Double.MinValue y Double.PositiveInfinity si s es mayor que Double.MaxValue.

Se aplica a

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analiza un intervalo de caracteres UTF-8 en un valor.

public static double Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> double
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, Optional provider As IFormatProvider = Nothing) As Double

Parámetros

utf8Text
ReadOnlySpan<Byte>

Intervalo de caracteres UTF-8 que se van a analizar.

style
NumberStyles

Combinación bit a bit de estilos de número que pueden estar presentes en utf8Text.

provider
IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre utf8Text.

Devoluciones

Resultado del análisis utf8Textde .

Implementaciones

Se aplica a

Parse(String, IFormatProvider)

Convierte la representación en forma de cadena de un número con un formato específico de la referencia cultural especificado en el número de punto flotante de precisión doble equivalente.

public:
 static double Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static double Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<double>::Parse;
public static double Parse (string s, IFormatProvider provider);
public static double Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> double
Public Shared Function Parse (s As String, provider As IFormatProvider) As Double

Parámetros

s
String

Cadena que contiene un número que se va a convertir.

provider
IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural acerca de s.

Devoluciones

Número de punto flotante de precisión doble equivalente al valor numérico o símbolo especificado en s.

Implementaciones

Excepciones

s no representa un número con un formato válido.

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que Double.MinValue o mayor que Double.MaxValue.

Ejemplos

El ejemplo siguiente es el controlador de eventos de clic de botón de un formulario web. Usa la matriz devuelta por la HttpRequest.UserLanguages propiedad para determinar la configuración regional del usuario. A continuación, crea una instancia de un CultureInfo objeto que corresponde a esa configuración regional. A NumberFormatInfo continuación, el objeto que pertenece a ese CultureInfo objeto se pasa al Parse(String, IFormatProvider) método para convertir la entrada del usuario en un Double valor.

protected void OkToDouble_Click(object sender, EventArgs e)
{
    string locale;
    double number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Double.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (OverflowException)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}
Protected Sub OkToDouble_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToDouble.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Double

   ' Return if string is empty
   If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub
   
   ' Get locale of web request to determine possible format of number
   If Request.UserLanguages.Length = 0 Then Exit Sub
   locale = Request.UserLanguages(0)
   If String.IsNullOrEmpty(locale) Then Exit Sub

   ' Instantiate CultureInfo object for the user's locale
   culture = New CultureInfo(locale)

   ' Convert user input from a string to a number
   Try
      number = Double.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As Exception
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

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 lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, analizar un valor demasiado grande para representar se produjo un error.

Esta sobrecarga del Parse(String, IFormatProvider) método se usa normalmente para convertir texto que se puede dar formato de varias maneras a un Double valor. Por ejemplo, se puede usar para convertir el texto escrito por un usuario en un cuadro de texto HTML a un valor numérico.

El s parámetro se interpreta mediante una combinación de las NumberStyles.Float marcas y NumberStyles.AllowThousands . El s parámetro puede contener NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol para la referencia cultural especificada por provider, o puede contener una cadena del formulario:

[ws] [sign] dígitos enteros[.[fracciones de dígitos]] [E[sign]exponential-digits] [ws]

Los elementos opcionales están enmarcados entre corchetes ([ y ]). Los elementos que contienen el término "dígitos" constan de una serie de caracteres numéricos comprendidos entre 0 y 9.

Elemento Descripción
ws Una serie de caracteres de espacio en blanco.
sign Un símbolo de signo negativo (-) o un símbolo de signo positivo (+).
dígitos enteros Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. Las ejecuciones de dígitos enteros se pueden particionar mediante un símbolo separador de grupo. Por ejemplo, en algunas referencias culturales, una coma (,) separa grupos de miles. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fractional-digits .
. Símbolo de separador decimal específico de la referencia cultural.
fracciones de dígitos Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número.
E Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica).
dígitos exponenciales Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente.

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

El provider parámetro es una IFormatProvider implementación cuyo GetFormat método devuelve un NumberFormatInfo objeto que proporciona información específica de la referencia cultural utilizada para interpretar el formato de s. Normalmente, es un NumberFormatInfo objeto o CultureInfo . Si provider es null o NumberFormatInfo no se puede obtener, se usa la información de formato de la referencia cultural del sistema actual.

Normalmente, si pasa el Double.Parse método una cadena que se crea mediante una llamada al Double.ToString método , se devuelve el valor original Double . Sin embargo, debido a una pérdida de precisión, los valores pueden no ser iguales. Además, al intentar analizar la representación de cadena de o Double.MinValue no se puede realizar un recorrido de ida y Double.MaxValue vuelta. En .NET Framework y .NET Core 2.2 y versiones anteriores, produce una OverflowExceptionexcepción . En .NET Core 3.0 y versiones posteriores, devuelve Double.NegativeInfinity si intenta analizar MinValue o Double.PositiveInfinity si intenta analizar MaxValue. Esto se muestra en el ejemplo siguiente.

   string value;

   value = Double.MinValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   value = Double.MaxValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   // Format without the default precision.
   value = Double.MinValue.ToString("G17");
   try
   {
       Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException)
   {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }
// 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.
//    -1.79769313486232E+308
open System

[<EntryPoint>]
let main _ =
    let value = string Double.MinValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    let value = string Double.MaxValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    // Format without the default precision.
    let value = Double.MinValue.ToString "G17"
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    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.
//    -1.79769313486232E+308
Dim value As String

value = Double.MinValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

value = Double.MaxValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

' Format without the default precision.
value = Double.MinValue.ToString("G17")
Try 
    Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try
' 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.            
'    -1.79769313486232E+308

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

En .NET Core 3.0 y versiones posteriores, no se produce ninguna excepción cuando s está fuera del intervalo del Double tipo de datos. En la mayoría de los casos, el Parse(String, IFormatProvider) método devolverá 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 son infinitos positivos o negativos. En esos casos, el método devuelve Double.MaxValue o Double.MinValue.

Si se encuentra un separador en el s parámetro durante una operación de análisis y los separadores decimales y de grupo aplicables son iguales, 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

Se aplica a

Parse(String)

Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión doble equivalente.

public:
 static double Parse(System::String ^ s);
public static double Parse (string s);
static member Parse : string -> double
Public Shared Function Parse (s As String) As Double

Parámetros

s
String

Cadena que contiene un número que se va a convertir.

Devoluciones

Número de punto flotante de precisión doble equivalente al valor numérico o símbolo especificado en s.

Excepciones

s no representa un número con un formato válido.

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que Double.MinValue o mayor que Double.MaxValue.

Ejemplos

En el ejemplo siguiente se muestra el uso del método Parse(String).

public ref class Temperature
{
   // Parses the temperature from a string in form
   // [ws][sign]digits['F|'C][ws]
public:
   static Temperature^ Parse( String^ s )
   {
      Temperature^ temp = gcnew Temperature;
      if ( s->TrimEnd(nullptr)->EndsWith( "'F" ) )
      {
         temp->Value = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ) );
      }
      else
      if ( s->TrimEnd(nullptr)->EndsWith( "'C" ) )
      {
         temp->Celsius = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ) );
      }
      else
      {
         temp->Value = Double::Parse( s );
      }

      return temp;
   }

protected:
   // The value holder
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }
      void set( double value )
      {
         m_value = value;
      }
   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }
      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }
   }
};
public class Temperature {
    // Parses the temperature from a string in form
    // [ws][sign]digits['F|'C][ws]
    public static Temperature Parse(string s) {
        Temperature temp = new Temperature();

        if( s.TrimEnd(null).EndsWith("'F") ) {
            temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2) );
        }
        else if( s.TrimEnd(null).EndsWith("'C") ) {
            temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2) );
        }
        else {
            temp.Value = Double.Parse(s);
        }

        return temp;
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}
type Temperature() =
    // Parses the temperature from a string in form
    // [ws][sign]digits['F|'C][ws]
    static member Parse(s: string) =
        let temp = Temperature()

        if s.TrimEnd(null).EndsWith "'F" then
            temp.Value <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2) )
        elif s.TrimEnd(null).EndsWith "'C" then
            temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2) )
        else
            temp.Value <- Double.Parse s
        temp

    member val Value = 0. with get, set

    member this.Celsius
        with get () =
            (this.Value - 32.) / 1.8
        and set (value) =
            this.Value <- 1.8 * value + 32.
Public Class Temperature
    ' Parses the temperature from a string in form
    ' [ws][sign]digits['F|'C][ws]
    Public Shared Function Parse(ByVal s As String) As Temperature
        Dim temp As New Temperature()

        If s.TrimEnd(Nothing).EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2))
        Else
            If s.TrimEnd(Nothing).EndsWith("'C") Then
                temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2))
            Else
                temp.Value = Double.Parse(s)
            End If
        End If
        Return temp
    End Function 'Parse

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

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 lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, analizar un valor demasiado grande para representar se produjo un error.

El s parámetro puede contener la referencia cultural actual NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.NaNSymbolo una cadena del formulario:

[ws] [sign] [entero-digits[,]] dígitos enteros[.[fracciones de dígitos]] [E[sign]exponential-digits] [ws]

Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.

Elemento Descripción
ws Una serie de caracteres de espacio en blanco.
sign Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). Solo se puede usar un signo inicial.
dígitos enteros Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. Las ejecuciones de dígitos enteros se pueden particionar mediante un símbolo separador de grupo. Por ejemplo, en algunas referencias culturales, una coma (,) separa grupos de miles. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fracciones de dígitos .
, Símbolo separador de miles específico de la referencia cultural.
. Símbolo de separador decimal específico de la referencia cultural.
fracciones de dígitos Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número.
E El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica).
dígitos exponenciales Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente.

El s parámetro se interpreta mediante una combinación de las NumberStyles.Float marcas y NumberStyles.AllowThousands . Esto significa que se permiten espacios en blanco y separadores de miles, por ejemplo, mientras que los símbolos de moneda no. Para un control más preciso sobre qué elementos de estilo se permiten en s para que la operación de análisis se realice correctamente, llame al Double.Parse(String, NumberStyles) método o Double.Parse(String, NumberStyles, IFormatProvider) .

El s parámetro se interpreta con la información de formato de un NumberFormatInfo objeto que se inicializa para la referencia cultural actual. Para obtener más información, vea CurrentInfo. Para analizar una cadena mediante la información de formato de alguna otra referencia cultural, llame al Double.Parse(String, IFormatProvider) método o Double.Parse(String, NumberStyles, IFormatProvider) .

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

   string value;

   value = Double.MinValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   value = Double.MaxValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   // Format without the default precision.
   value = Double.MinValue.ToString("G17");
   try
   {
       Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException)
   {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }
// 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.
//    -1.79769313486232E+308
open System

[<EntryPoint>]
let main _ =
    let value = string Double.MinValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    let value = string Double.MaxValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    // Format without the default precision.
    let value = Double.MinValue.ToString "G17"
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    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.
//    -1.79769313486232E+308
Dim value As String

value = Double.MinValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

value = Double.MaxValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

' Format without the default precision.
value = Double.MinValue.ToString("G17")
Try 
    Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try
' 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.            
'    -1.79769313486232E+308

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

En .NET Core 3.0 y versiones posteriores, no se produce ninguna excepción cuando s está fuera del intervalo del Double tipo de datos. En la mayoría de los casos, el método devolverá 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 devuelve Double.MaxValue o Double.MinValue.

Si se encuentra un separador en el s parámetro durante una operación de análisis y los separadores decimales y de número y número 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

Se aplica a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analiza un intervalo de caracteres en un valor.

public:
 static double Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<double>::Parse;
public static double Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> double
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Double

Parámetros

s
ReadOnlySpan<Char>

Intervalo de caracteres que se van a analizar.

provider
IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre s.

Devoluciones

Resultado del análisis sde .

Implementaciones

Se aplica a

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Analiza un intervalo de caracteres UTF-8 en un valor.

public:
 static double Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<double>::Parse;
public static double Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> double
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Double

Parámetros

utf8Text
ReadOnlySpan<Byte>

Intervalo de caracteres UTF-8 que se van a analizar.

provider
IFormatProvider

Un objeto que proporciona información de formato específica de la referencia cultural sobre utf8Text.

Devoluciones

Resultado del análisis utf8Textde .

Implementaciones

Se aplica a

Parse(String, NumberStyles)

Convierte la representación en forma de cadena de un número con un estilo especificado en el número de punto flotante de precisión doble equivalente.

public:
 static double Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static double Parse (string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> double
Public Shared Function Parse (s As String, style As NumberStyles) As Double

Parámetros

s
String

Cadena que contiene un número que se va a convertir.

style
NumberStyles

Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s. Un valor que se especifica de forma habitual es una combinación de Float combinado con AllowThousands.

Devoluciones

Número de punto flotante de precisión doble equivalente al valor numérico o símbolo especificado en s.

Excepciones

s no representa un número con un formato válido.

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que Double.MinValue o mayor que Double.MaxValue.

style no es un valor NumberStyles.

O bien

style incluye el valor AllowHexSpecifier

Ejemplos

En el ejemplo siguiente se usa el Parse(String, NumberStyles) método para analizar las representaciones de cadena de Double los valores mediante la referencia cultural en-US.

public static void Main()
{
   // Set current thread culture to en-US.
   Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");

   string value;
   NumberStyles styles;

   // Parse a string in exponential notation with only the AllowExponent flag.
   value = "-1.063E-02";
   styles = NumberStyles.AllowExponent;
   ShowNumericValue(value, styles);

   // Parse a string in exponential notation
   // with the AllowExponent and Number flags.
   styles = NumberStyles.AllowExponent | NumberStyles.Number;
   ShowNumericValue(value, styles);

   // Parse a currency value with leading and trailing white space, and
   // white space after the U.S. currency symbol.
   value = " $ 6,164.3299  ";
   styles = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
   ShowNumericValue(value, styles);

   // Parse negative value with thousands separator and decimal.
   value = "(4,320.64)";
   styles = NumberStyles.AllowParentheses | NumberStyles.AllowTrailingSign |
            NumberStyles.Float;
   ShowNumericValue(value, styles);

   styles = NumberStyles.AllowParentheses | NumberStyles.AllowTrailingSign |
            NumberStyles.Float | NumberStyles.AllowThousands;
   ShowNumericValue(value, styles);
}

private static void ShowNumericValue(string value, NumberStyles styles)
{
   double number;
   try
   {
      number = Double.Parse(value, styles);
      Console.WriteLine("Converted '{0}' using {1} to {2}.",
                        value, styles.ToString(), number);
   }
   catch (FormatException)
   {
      Console.WriteLine("Unable to parse '{0}' with styles {1}.",
                        value, styles.ToString());
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//    Unable to parse '-1.063E-02' with styles AllowExponent.
//
//    Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
//
//    Converted ' $ 6,164.3299  ' using Number, AllowCurrencySymbol to 6164.3299.
//
//    Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
//
//    Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.
open System
open System.Globalization
open System.Threading

let showNumericValue (value: string) (styles: NumberStyles) =
    try
        let number = Double.Parse(value, styles)
        printfn $"Converted '{value}' using {styles} to {number}."
    with :? FormatException ->
        printfn $"Unable to parse '{value}' with styles {styles}."
    printfn ""

[<EntryPoint>]
let main _ =
    // Set current thread culture to en-US.
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"

    // Parse a string in exponential notation with only the AllowExponent flag.
    let value = "-1.063E-02"
    let styles = NumberStyles.AllowExponent
    showNumericValue value styles

    // Parse a string in exponential notation
    // with the AllowExponent and Number flags.
    let styles = NumberStyles.AllowExponent ||| NumberStyles.Number
    showNumericValue value styles

    // Parse a currency value with leading and trailing white space, and
    // white space after the U.S. currency symbol.
    let value = " $ 6,164.3299  "
    let styles = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
    showNumericValue value styles

    // Parse negative value with thousands separator and decimal.
    let value = "(4,320.64)"
    let styles = 
        NumberStyles.AllowParentheses ||| NumberStyles.AllowTrailingSign ||| NumberStyles.Float
    showNumericValue value styles

    let styles = 
        NumberStyles.AllowParentheses ||| NumberStyles.AllowTrailingSign ||| NumberStyles.Float ||| NumberStyles.AllowThousands
    showNumericValue value styles

    0

// The example displays the following output to the console:
//    Unable to parse '-1.063E-02' with styles AllowExponent.
//
//    Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
//
//    Converted ' $ 6,164.3299  ' using Number, AllowCurrencySymbol to 6164.3299.
//
//    Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
//
//    Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.
Public Sub Main()
   ' Set current thread culture to en-US.
   Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
         
   Dim value As String
   Dim styles As NumberStyles
   
   ' Parse a string in exponential notation with only the AllowExponent flag. 
   value = "-1.063E-02"
   styles = NumberStyles.AllowExponent
   ShowNumericValue(value, styles) 
   
   ' Parse a string in exponential notation
   ' with the AllowExponent and Number flags.
   styles = NumberStyles.AllowExponent Or NumberStyles.Number
   ShowNumericValue(value, styles)

   ' Parse a currency value with leading and trailing white space, and
   ' white space after the U.S. currency symbol.
   value = " $ 6,164.3299  "
   styles = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
   ShowNumericValue(value, styles)
   
   ' Parse negative value with thousands separator and decimal.
   value = "(4,320.64)"
   styles = NumberStyles.AllowParentheses Or NumberStyles.AllowTrailingSign _
            Or NumberStyles.Float 
   ShowNumericValue(value, styles)
   
   styles = NumberStyles.AllowParentheses Or NumberStyles.AllowTrailingSign _
            Or NumberStyles.Float Or NumberStyles.AllowThousands
   ShowNumericValue(value, styles)
End Sub

Private Sub ShowNumericValue(value As String, styles As NumberStyles)
   Dim number As Double
   Try
      number = Double.Parse(value, styles)
      Console.WriteLine("Converted '{0}' using {1} to {2}.", _
                        value, styles.ToString(), number)
   Catch e As FormatException
      Console.WriteLine("Unable to parse '{0}' with styles {1}.", _
                        value, styles.ToString())
   End Try
   Console.WriteLine()                           
End Sub
' The example displays the following output to the console:
'    Unable to parse '-1.063E-02' with styles AllowExponent.
'    
'    Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
'    
'    Converted ' $ 6,164.3299  ' using Number, AllowCurrencySymbol to 6164.3299.
'    
'    Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
'    
'    Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.

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 lo requiera 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 style parámetro define los elementos de estilo (como espacios en blanco, separadores de miles y símbolos de moneda) que se permiten en el s parámetro para que la operación de análisis se realice correctamente. Debe ser una combinación de marcas de bits de la NumberStyles enumeración. No se admiten los siguientes NumberStyles miembros:

El s parámetro puede contener la referencia cultural actual NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol. Dependiendo del valor de style, también puede tomar la forma:

[ws] [$][sign][integral-digits[,]]integral-digits[.[fracciones de dígitos]] [E[sign]exponencial-digits] [ws]

Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.

Elemento Descripción
ws Una serie de caracteres de espacio en blanco. El espacio en blanco puede aparecer al principio de s si incluye la NumberStyles.AllowLeadingWhite marca y puede aparecer al final de s si style incluye la NumberStyles.AllowTrailingWhitestyle marca.
$ Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las NumberFormatInfo.CurrencyNegativePattern propiedades y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural actual. El símbolo de moneda de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowCurrencySymbol marca .
sign Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). El signo puede aparecer al principio de s si incluye la NumberStyles.AllowLeadingSign marca y puede aparecer al final de s si style incluye la NumberStyles.AllowTrailingSignstyle marca. Los paréntesis se pueden usar en s para indicar un valor negativo si style incluye la NumberStyles.AllowParentheses marca .
dígitos enteros Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fracciones de dígitos .
, Separador de grupo específico de la referencia cultural. El símbolo separador de grupo de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowThousands marca .
. Símbolo de separador decimal específico de la referencia cultural. El símbolo de separador decimal de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowDecimalPoint marca .
fracciones de dígitos Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número. Los dígitos fraccionarios pueden aparecer en s si style incluye la NumberStyles.AllowDecimalPoint marca .
E El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El s parámetro puede representar un número en notación exponencial si style incluye la NumberStyles.AllowExponent marca .
dígitos exponenciales Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente.

Nota

La operación de análisis omite todos los caracteres NUL (U+0000) de s , independientemente del valor del style argumento.

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

Valor NumberStyles Elementos permitidos además s de dígitos
None Solo el elemento integral-digits .
AllowDecimalPoint Elementos decimales (.) y fracciones de dígitos .
AllowExponent El carácter "e" o "E", que indica la notación exponencial. Esta marca por sí misma admite valores en los dígitosde formaE digits; se necesitan marcas adicionales para analizar correctamente cadenas con elementos como signos positivos o negativos y símbolos decimales.
AllowLeadingWhite Elemento ws al principio de s.
AllowTrailingWhite Elemento ws al final de s.
AllowLeadingSign Elemento sign al principio de s.
AllowTrailingSign Elemento sign al final de s.
AllowParentheses Elemento de signo en forma de paréntesis que incluye el valor numérico.
AllowThousands Elemento separador de miles (,).
AllowCurrencySymbol Elemento currency ($).
Currency Todos los elementos. Sin embargo, s no puede representar un número hexadecimal o un número en notación exponencial.
Float Elemento ws al principio o al final de s, signo al principio de sy el símbolo decimal (.). El s parámetro también puede usar la notación exponencial.
Number Los wselementos separadores , sign, miles (,) y decimal point (.).
Any Todos los elementos. Sin embargo, s no puede representar un número hexadecimal.

El s parámetro se analiza mediante la información de formato de un NumberFormatInfo objeto que se inicializa para la referencia cultural del sistema actual. Para obtener más información, vea CurrentInfo.

Normalmente, si pasa el Double.Parse método una cadena que se crea llamando al Double.ToString método , se devuelve el valor original Double . 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 o Double.MinValue no se puede realizar un recorrido de ida y Double.MaxValue vuelta. En .NET Framework y .NET Core 2.2 y versiones anteriores, inicia una OverflowExceptionexcepción . En .NET Core 3.0 y versiones posteriores, devuelve Double.NegativeInfinity si intenta analizar MinValue o Double.PositiveInfinity si intenta analizar MaxValue. Esto se muestra en el ejemplo siguiente.

   string value;

   value = Double.MinValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   value = Double.MaxValue.ToString();
   try {
      Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException) {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }

   // Format without the default precision.
   value = Double.MinValue.ToString("G17");
   try
   {
       Console.WriteLine(Double.Parse(value));
   }
   catch (OverflowException)
   {
      Console.WriteLine($"{value} is outside the range of the Double type.");
   }
// 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.
//    -1.79769313486232E+308
open System

[<EntryPoint>]
let main _ =
    let value = string Double.MinValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    let value = string Double.MaxValue
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    // Format without the default precision.
    let value = Double.MinValue.ToString "G17"
    try
        printfn $"{Double.Parse value}"
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Double type."

    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.
//    -1.79769313486232E+308
Dim value As String

value = Double.MinValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

value = Double.MaxValue.ToString()
Try
   Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try

' Format without the default precision.
value = Double.MinValue.ToString("G17")
Try 
    Console.WriteLine(Double.Parse(value))
Catch e As OverflowException
   Console.WriteLine($"{value} is outside the range of the Double type.")
End Try
' 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.            
'    -1.79769313486232E+308

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

En .NET Core 3.0 y versiones posteriores, no se produce ninguna excepción cuando s está fuera del intervalo del Double tipo de datos. En la mayoría de los casos, el Parse(String, NumberStyles) método devolverá 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 devuelve Double.MaxValue o Double.MinValue.

Si se encuentra un separador en el s parámetro durante una operación de análisis y los separadores decimales y de número y número 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

Se aplica a