Double.Parse Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Convierte la representación de cadena de un número en su número de punto flotante de precisión doble equivalente.
Sobrecargas
Parse(String) |
Convierte la representación de cadena de un número en su número de punto flotante de precisión doble equivalente. |
Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Analiza un intervalo de caracteres UTF-8 en un valor. |
Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analiza un intervalo de caracteres en un valor. |
Parse(String, NumberStyles) |
Convierte la representación de cadena de un número en un estilo especificado en su número de punto flotante de precisión doble equivalente. |
Parse(String, IFormatProvider) |
Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado a su 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(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Convierte un intervalo de caracteres que contiene la representación de cadena de un número en un estilo especificado y un formato específico de la referencia cultural a su número de punto flotante de precisión doble equivalente. |
Parse(String, NumberStyles, IFormatProvider) |
Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su 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 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.
Parse(String)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Convierte la representación de cadena de un número en su 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
es null
.
s
no representa un número en 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 superior a 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 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 parámetro s
puede contener la referencia cultural actual NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.NaNSymbolo una cadena del formulario:
[ws] [signo] [enteros [,]]dígitos enteros[.[fracciones de dígitos]][E[signo]dígitos exponenciales][ws]
Los elementos entre corchetes ([ y ]) son opcionales. En la tabla siguiente se describe cada elemento.
Elemento | Descripción |
---|---|
ws | Una serie de caracteres de espacio en blanco. |
de signo | Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). Solo se puede usar un signo inicial. |
de dígitos enteros | Serie de dígitos que van de 0 a 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 dígitos enteros puede estar ausente si la cadena contiene los dígitos fraccionarios elemento. |
, | 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 que van de 0 a 9 que especifican la parte fraccionaria del número. |
E | Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). |
de dígitos exponenciales | Serie de dígitos que van de 0 a 9 que especifican un exponente. |
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, 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) o al método Double.Parse(String, NumberStyles, IFormatProvider).
El parámetro s
se interpreta mediante la información de formato de un objeto NumberFormatInfo que se inicializa para la referencia cultural actual. Para obtener más información, consulte CurrentInfo. Para analizar una cadena mediante la información de formato de alguna otra referencia cultural, llame al método Double.Parse(String, IFormatProvider) o Double.Parse(String, NumberStyles, IFormatProvider).
Normalmente, si pasa el método Double.Parse una cadena que se crea llamando al método Double.ToString, se devuelve el valor de Double original. 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 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 el ejemplo siguiente se proporciona una ilustración.
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 datos Double, el método Parse(String) 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 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 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
Se aplica a
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Source:
- Double.cs
- Source:
- Double.cs
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
Objeto que proporciona información de formato específica de la referencia cultural sobre utf8Text
.
Devoluciones
Resultado del análisis utf8Text
.
Implementaciones
Se aplica a
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
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 va a analizar.
- provider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural sobre s
.
Devoluciones
Resultado del análisis s
.
Implementaciones
Se aplica a
Parse(String, NumberStyles)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Convierte la representación de cadena de un número en un estilo especificado en su 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 valores de enumeración que indican los elementos de estilo que pueden estar presentes en s
. Un valor típico que se debe especificar 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
es null
.
s
no representa un número en 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 superior a Double.MaxValue.
Ejemplos
En el ejemplo siguiente se usa el método Parse(String, NumberStyles) para analizar las representaciones de cadena de Double 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 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 parámetro style
define los elementos de estilo (como espacios en blanco, separadores de miles y símbolos de moneda) que se permiten en el 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:
El parámetro s
puede contener la referencia cultural actual NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol. Dependiendo del valor de style
, también puede adoptar la forma:
[
Los elementos entre corchetes ([ y ]) son opcionales. En la tabla siguiente 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 style incluye la marca NumberStyles.AllowLeadingWhite y puede aparecer al final de s si style incluye la marca NumberStyles.AllowTrailingWhite. |
$ | Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las propiedades NumberFormatInfo.CurrencyNegativePattern 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 marca NumberStyles.AllowCurrencySymbol. |
de signo | Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). El signo puede aparecer al principio de s si style incluye la marca NumberStyles.AllowLeadingSign y puede aparecer al final de s si style incluye la marca NumberStyles.AllowTrailingSign. Los paréntesis se pueden usar en s para indicar un valor negativo si style incluye la marca NumberStyles.AllowParentheses. |
de dígitos enteros | Serie de dígitos que van de 0 a 9 que especifican la parte integral del número. El elemento dígitos enteros puede estar ausente si la cadena contiene los dígitos fraccionarios elemento. |
, | 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 marca de NumberStyles.AllowThousands |
. | 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 marca NumberStyles.AllowDecimalPoint. |
fracciones de dígitos | Serie de dígitos que van de 0 a 9 que especifican la parte fraccionaria del número. Los dígitos fraccionarios pueden aparecer en s si style incluye la marca NumberStyles.AllowDecimalPoint. |
E | Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El parámetro s puede representar un número en notación exponencial si style incluye la marca NumberStyles.AllowExponent. |
de dígitos exponenciales | Serie de dígitos que van de 0 a 9 que especifican un exponente. |
Nota
La operación de análisis omite los caracteres NUL (U+0000) de s
, independientemente del valor del argumento style
.
Una cadena solo con dígitos (que corresponde al estilo NumberStyles.None) siempre analiza correctamente si está en el intervalo del tipo Double. El resto de System.Globalization.NumberStyles miembros 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
.
Valor numberStyles | Elementos permitidos en s además de dígitos |
---|---|
None | Los solo dígitos enteros elemento. |
AllowDecimalPoint | El separador decimal (.) y los dígitos fraccionarios elementos. |
AllowExponent | Carácter "e" o "E", que indica la notación exponencial. Esta marca admite valores en forma dígitosEdígitos; Se necesitan marcas adicionales para analizar correctamente las 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 de signo |
AllowTrailingSign | Elemento |
AllowParentheses | El signo elemento 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 ni un número en notación exponencial. |
Float | Elemento ws al principio o al final de s , signo al principio de s y el símbolo decimal (.). El parámetro s también puede usar la notación exponencial. |
Number | Los elementos ws , sign , separador de miles (,) y separador decimal (.). |
Any | Todos los elementos. Sin embargo, s no puede representar un número hexadecimal. |
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 CurrentInfo.
Normalmente, si pasa el método Double.Parse 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.
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 datos Double, el método Parse(String, NumberStyles) 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 Parse(String, NumberStyles) 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 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
Se aplica a
Parse(String, IFormatProvider)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado a su 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 sobre 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
es null
.
s
no representa un número en 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 superior a Double.MaxValue.
Ejemplos
El ejemplo siguiente es el controlador de eventos click de botón de un formulario web. Usa la matriz devuelta por la propiedad HttpRequest.UserLanguages para determinar la configuración regional del usuario. A continuación, crea una instancia de un objeto CultureInfo que corresponde a esa configuración regional. A continuación, el objeto NumberFormatInfo que pertenece a ese objeto CultureInfo se pasa al método Parse(String, IFormatProvider) para convertir la entrada del usuario en un valor de Double.
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 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 del método Parse(String, IFormatProvider) se usa normalmente para convertir texto que se puede dar formato de varias maneras a un valor de Double. 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 parámetro s
se interpreta mediante una combinación de las marcas NumberStyles.Float y NumberStyles.AllowThousands. El parámetro s
puede contener NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol para la referencia cultural especificada por provider
o puede contener una cadena del formulario:
[ws] [signo]de dígitos enteros [.[fracciones de dígitos]][E[signo]dígitos exponenciales][ws]
Los elementos opcionales se enmarcan entre corchetes ([ y ]). Los elementos que contienen el término "dígitos" constan de una serie de caracteres numéricos que van de 0 a 9.
Elemento | Descripción |
---|---|
ws | Una serie de caracteres de espacio en blanco. |
de signo | Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). |
de dígitos enteros | Serie de dígitos que van de 0 a 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 dígitos enteros puede estar ausente si la cadena contiene los dígitos fraccionarios elemento. |
. | Símbolo de separador decimal específico de la referencia cultural. |
fracciones de dígitos | Serie de dígitos que van de 0 a 9 que especifican la parte fraccionaria del número. |
E | Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). |
de dígitos exponenciales | Serie de dígitos que van de 0 a 9 que especifican un exponente. |
Para obtener más información sobre los formatos numéricos, consulte el tema Tipos de formato.
El parámetro provider
es una implementación de IFormatProvider cuyo método GetFormat devuelve un objeto NumberFormatInfo que proporciona información específica de la referencia cultural utilizada para interpretar el formato de s
. Normalmente, es un objeto NumberFormatInfo o CultureInfo. Si provider
es null
o no se puede obtener un NumberFormatInfo, se usa la información de formato de la referencia cultural del sistema actual.
Normalmente, si pasa el método Double.Parse 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.
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 datos Double, el método Parse(String, IFormatProvider) 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 Parse(String, IFormatProvider) 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 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
Se aplica a
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Source:
- Double.cs
- Source:
- Double.cs
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
Objeto que proporciona información de formato específica de la referencia cultural sobre utf8Text
.
Devoluciones
Resultado del análisis utf8Text
.
Implementaciones
Se aplica a
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Convierte un intervalo de caracteres que contiene la representación de cadena de un número en un estilo especificado y un formato específico de la referencia cultural a su 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>
Intervalo de caracteres que contiene el número que se va a convertir.
- style
- NumberStyles
Combinación bit a bit de valores de enumeración que indican los elementos de estilo que pueden estar presentes en s
. Un valor típico que se debe especificar se Float combinado con AllowThousands.
- provider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural sobre 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.
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.
Si s
está fuera del intervalo del tipo de datos Double, 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(String, NumberStyles, IFormatProvider)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su 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 valores de enumeración que indican los elementos de estilo que pueden estar presentes en s
. Un valor típico que se debe especificar se Float combinado con AllowThousands.
- provider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural sobre 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
es null
.
s
no representa un valor numérico.
.NET Framework y .NET Core 2.2 y versiones anteriores solo: s
representa un número menor que double.MinValue o superior a Double.MaxValue.
Ejemplos
En el ejemplo siguiente se muestra el uso del método Parse(String, NumberStyles, IFormatProvider) para asignar varias representaciones de cadena de valores de temperatura a un objeto Temperature
.
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 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 parámetro style
define los elementos de estilo (como espacios en blanco, separadores de miles y símbolos de moneda) que se permiten en el 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:
El parámetro s
puede contener NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol para la referencia cultural especificada por provider
. Dependiendo del valor de style
, también puede adoptar la forma:
[
Los elementos enmarcados entre corchetes ([ y ]) son opcionales. En la tabla siguiente 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 style incluye la marca NumberStyles.AllowLeadingWhite y puede aparecer al final de s si style incluye la marca NumberStyles.AllowTrailingWhite. |
$ | Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las propiedades NumberFormatInfo.CurrencyNegativePattern 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 marca NumberStyles.AllowCurrencySymbol. |
de signo | Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). El signo puede aparecer al principio de s si style incluye la marca NumberStyles.AllowLeadingSign y puede aparecer al final de s si style incluye la marca NumberStyles.AllowTrailingSign. Los paréntesis se pueden usar en s para indicar un valor negativo si style incluye la marca NumberStyles.AllowParentheses. |
de dígitos enteros | Serie de dígitos que van de 0 a 9 que especifican la parte integral del número. El elemento dígitos enteros puede estar ausente si la cadena contiene los dígitos fraccionarios elemento. |
, | 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 marca de NumberStyles.AllowThousands |
. | 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 marca NumberStyles.AllowDecimalPoint. |
fracciones de dígitos | Serie de dígitos que van de 0 a 9 que especifican la parte fraccionaria del número. Los dígitos fraccionarios pueden aparecer en s si style incluye la marca NumberStyles.AllowDecimalPoint. |
E | Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El parámetro s puede representar un número en notación exponencial si style incluye la marca NumberStyles.AllowExponent. |
de dígitos exponenciales | Serie de dígitos que van de 0 a 9 que especifican un exponente. |
Nota
La operación de análisis omite los caracteres NUL (U+0000) de s
, independientemente del valor del argumento style
.
Una cadena solo con dígitos (que corresponde al estilo NumberStyles.None) siempre analiza correctamente si está en el intervalo del tipo Double. El resto de System.Globalization.NumberStyles miembros 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
.
Valor numberStyles | Elementos permitidos en s además de dígitos |
---|---|
None | Los solo dígitos enteros elemento. |
AllowDecimalPoint | El separador decimal (.) y los dígitos fraccionarios elementos. |
AllowExponent | Carácter "e" o "E", que indica la notación exponencial. Esta marca admite valores en forma dígitosEdígitos; Se necesitan marcas adicionales para analizar correctamente las 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 de signo |
AllowTrailingSign | Elemento |
AllowParentheses | El signo elemento 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 ni un número en notación exponencial. |
Float | Elemento ws al principio o al final de s , signo al principio de s y el símbolo decimal (.). El parámetro s también puede usar la notación exponencial. |
Number | Los elementos ws , sign , separador de miles (,) y separador decimal (.). |
Any | Todos los elementos. Sin embargo, s no puede representar un número hexadecimal. |
El parámetro provider
es una implementación de IFormatProvider cuyo método GetFormat devuelve un objeto NumberFormatInfo que proporciona información específica de la referencia cultural utilizada para interpretar el formato de s
. Normalmente, es un objeto NumberFormatInfo o CultureInfo. Si provider
es null
o no se puede obtener un NumberFormatInfo, se usa la información de formato de la referencia cultural del sistema actual.
Normalmente, si pasa el método Double.Parse 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 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.
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 datos Double, el método Parse(String, NumberStyles, IFormatProvider) 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 Parse(String, NumberStyles, IFormatProvider) 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 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
Se aplica a
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea:Enviar y ver comentarios de