Double.Parse Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Converte a representação da cadeia de caracteres de um número no equivalente do número de ponto flutuante de precisão dupla.
Sobrecargas
Parse(String) |
Converte a representação da cadeia de caracteres de um número no equivalente do número de ponto flutuante de precisão dupla. |
Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Analisa um intervalo de caracteres UTF-8 em um valor. |
Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analisa um intervalo de caracteres em um valor. |
Parse(String, NumberStyles) |
Converte a representação de cadeia de caracteres de um número em um estilo especificado para o número de ponto flutuante de precisão dupla equivalente. |
Parse(String, IFormatProvider) |
Converte a representação de cadeia de caracteres de um número em um formato específico da cultura para o número de ponto flutuante de precisão dupla equivalente. |
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Analisa um intervalo de caracteres UTF-8 em um valor. |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Converte um intervalo de caracteres que contém a representação de cadeia de caracteres de um número em um formato específico de cultura e um estilo especificados para o número de ponto flutuante de precisão dupla equivalente. |
Parse(String, NumberStyles, IFormatProvider) |
Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla equivalente. |
Comentários
No .NET Core 3.0 e posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .NET Framework, a análise de um valor muito grande para representar resultou em falha.
Parse(String)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte a representação da cadeia de caracteres de um número no equivalente do número de ponto flutuante de precisão dupla.
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
Uma cadeia de caracteres que contém um número a ser convertido.
Retornos
Um número de ponto flutuante de precisão dupla que é equivalente ao valor numérico ou ao símbolo especificado em s
.
Exceções
s
é null
.
s
não representa um número em um formato válido.
.NET Framework e .NET Core 2.2 e somente versões anteriores: s
representa um número menor que Double.MinValue ou maior que Double.MaxValue.
Exemplos
O exemplo a seguir ilustra o uso do 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
Comentários
No .NET Core 3.0 e posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .NET Framework, a análise de um valor muito grande para representar resultou em falha.
O s
parâmetro pode conter , , NumberFormatInfo.NaNSymbolou uma cadeia de caracteres da cultura NumberFormatInfo.PositiveInfinitySymbolNumberFormatInfo.NegativeInfinitySymbolatual do formulário:
[ws] [sign] [dígitos integrais[,]] dígitos integrais[.[dígitos fracionários]] [E[sign]exponential-digits] [ws]
Os elementos entre colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.
Elemento | Descrição |
---|---|
ws | Uma série de caracteres de espaço em branco. |
sign | Um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+). Somente um sinal à esquerda pode ser usado. |
dígitos integrais | Uma série de dígitos que varia de 0 a 9 que especificam a parte integral do número. Execuções de dígitos integrais podem ser particionadas por um símbolo separador de grupo. Por exemplo, em algumas culturas, uma vírgula (,) separa grupos de milhares. O elemento de dígitos integrais poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários . |
, | Um símbolo de separador de milhares específico da cultura. |
. | Um símbolo de vírgula decimal específico de cultura. |
dígitos fracionários | Uma série de dígitos que varia de 0 a 9 que especificam a parte fracionária do número. |
E | O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). |
dígitos exponenciais | Uma série de dígitos que varia de 0 a 9 que especificam um expoente. |
O parâmetro s
é interpretado usando-se uma combinação dos sinalizadores NumberStyles.Float e NumberStyles.AllowThousands. Isso significa que o espaço em branco e milhares de separadores são permitidos, por exemplo, enquanto os símbolos de moeda não são. Para obter um controle mais fino sobre em quais elementos de estilo são permitidos s
para que a operação de análise tenha êxito, chame o Double.Parse(String, NumberStyles)Double.Parse(String, NumberStyles, IFormatProvider) método ou .
O s
parâmetro é interpretado usando as informações de formatação em um NumberFormatInfo objeto inicializado para a cultura atual. Para obter mais informações, consulte CurrentInfo. Para analisar uma cadeia de caracteres usando as informações de formatação de alguma outra cultura, chame o Double.Parse(String, IFormatProvider) método ou Double.Parse(String, NumberStyles, IFormatProvider) .
Normalmente, se você passa ao método Double.Parse, uma cadeia de caracteres criada chamando-se o método Double.ToString, o valor Double original é retornado. No entanto, em .NET Framework e no .NET Core 2.2 e versões anteriores, os valores podem não ser iguais devido à perda de precisão. Além disso, tentar analisar a representação de cadeia de caracteres de Double.MinValue ou falha na viagem de ida e Double.MaxValue volta. No .NET Framework e no .NET Core 2.2 e nas versões anteriores, ele lança um OverflowException. O exemplo a seguir ilustra esse cenário.
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
No .NET Framework e no .NET Core 2.2 e versões anteriores, se s
estiver fora do intervalo do tipo de Double dados, o Parse(String) método gerará um OverflowException.
No .NET Core 3.0 e versões posteriores, nenhuma exceção é gerada quando s
está fora do intervalo do tipo de Double dados. Na maioria dos casos, o método retornará Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, há um pequeno conjunto de valores que são considerados mais próximos dos valores máximo ou mínimo de Double do que para infinito positivo ou negativo. Nesses casos, o método retorna Double.MaxValue ou Double.MinValue.
Caso um separador esteja no parâmetro s
durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e NumberGroupSeparator.
Confira também
Aplica-se a
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Origem:
- Double.cs
- Origem:
- Double.cs
Analisa um intervalo de caracteres UTF-8 em um 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>
O intervalo de caracteres UTF-8 a serem analisados.
- provider
- IFormatProvider
Um objeto que fornece informações de formatação específicas à cultura sobre utf8Text
.
Retornos
O resultado da análise utf8Text
.
Implementações
Aplica-se a
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Analisa um intervalo de caracteres em um 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>
O intervalo de caracteres a serem analisados.
- provider
- IFormatProvider
Um objeto que fornece informações de formatação específicas à cultura sobre s
.
Retornos
O resultado da análise s
.
Implementações
Aplica-se a
Parse(String, NumberStyles)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte a representação de cadeia de caracteres de um número em um estilo especificado para o número de ponto flutuante de precisão dupla 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
Uma cadeia de caracteres que contém um número a ser convertido.
- style
- NumberStyles
Uma combinação bit a bit de valores de enumeração que indicam os elementos de estilo que podem estar presentes em s
. Um valor típico para especificar é uma combinação de Float combinado com AllowThousands.
Retornos
Um número de ponto flutuante de precisão dupla que é equivalente ao valor numérico ou ao símbolo especificado em s
.
Exceções
s
é null
.
s
não representa um número em um formato válido.
.NET Framework e .NET Core 2.2 e somente versões anteriores: s
representa um número menor que Double.MinValue ou maior que Double.MaxValue.
Exemplos
O exemplo a seguir usa o Parse(String, NumberStyles) método para analisar as representações de cadeia de caracteres de Double valores usando a cultura 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.
Comentários
No .NET Core 3.0 e posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .NET Framework, a análise de um valor muito grande para representar resultou em falha.
O parâmetro style
define os elementos de estilo (como espaço em branco, separadores de milhares e símbolos de moeda) que são permitidos no parâmetro s
para que a operação de análise seja bem-sucedida. Ele deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Os seguintes membros NumberStyles não são suportados:
O s
parâmetro pode conter , NumberFormatInfo.PositiveInfinitySymbolNumberFormatInfo.NegativeInfinitySymbolou NumberFormatInfo.NaNSymbol. Dependendo do valor de style
, ele também pode assumir a forma:
[ws] [$][sign][integral-digits[,]]integral-digits[.[dígitos fracionários]] [E[sign]exponential-digits] [ws]
Os elementos entre colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.
Elemento | Descrição |
---|---|
ws | Uma série de caracteres de espaço em branco. Espaço em branco pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingWhite e pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingWhite. |
$ | Um símbolo de moeda específico de cultura. A posição na cadeia de caracteres é definida pelas propriedades NumberFormatInfo.CurrencyNegativePattern e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo de moeda da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol. |
sign | Um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+). O sinal pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingSign e ele pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingSign. Os parênteses podem ser usados em s para indicar um valor negativo caso style inclua o sinalizador NumberStyles.AllowParentheses. |
dígitos integrais | Uma série de dígitos que varia de 0 a 9 que especificam a parte integral do número. O elemento de dígitos integrais poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários . |
, | Um separador de grupo específico de cultura. O símbolo do separador do grupo da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowThousands |
. | Um símbolo de vírgula decimal específico de cultura. O símbolo da vírgula decimal da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowDecimalPoint. |
dígitos fracionários | Uma série de dígitos que varia de 0 a 9 que especificam a parte fracionária do número. Os dígitos fracionários podem ser exibidos em s caso style inclua o sinalizador NumberStyles.AllowDecimalPoint. |
E | O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O parâmetro s pode representar um número em notação exponencial caso style inclua o sinalizador NumberStyles.AllowExponent. |
dígitos exponenciais | Uma série de dígitos que varia de 0 a 9 que especificam um expoente. |
Observação
Todos os caracteres NUL de terminação (U+0000) no s
são ignorados pela operação de análise, independentemente do valor do style
argumento.
Uma cadeia de caracteres apenas com dígitos (que corresponde ao estilo NumberStyles.None ) sempre é analisada com Double êxito. Os elementos de controle dos membros System.Globalization.NumberStyles restantes que podem estar presentes, mas que não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como os sinalizadores individuais NumberStyles afetam os elementos que podem estar presentes em s
.
Valor NumberStyles | Elementos permitidos em s além de dígitos |
---|---|
None | Somente o elemento de dígitos integrais . |
AllowDecimalPoint | Os elementos de ponto decimal (.) e de dígitos fracionários . |
AllowExponent | O caractere "e" ou "E", que indica a notação exponencial. Esse sinalizador por si só dá suporte a valores nos dígitosde formulário Edígitos; sinalizadores adicionais são necessários para analisar com êxito cadeias de caracteres com elementos como sinais positivos ou negativos e símbolos de ponto decimal. |
AllowLeadingWhite | O elemento ws no início de s . |
AllowTrailingWhite | O elemento ws no final de s . |
AllowLeadingSign | O elemento sinal no início de s . |
AllowTrailingSign | O elemento sinal no final de s . |
AllowParentheses | O elemento sinal na forma de parênteses que incluem o valor numérico. |
AllowThousands | O elemento separador de milhares (.). |
AllowCurrencySymbol | O elemento de moeda ($). |
Currency | Todos os elementos. No entanto, s não pode representar um número hexadecimal ou um número em notação exponencial. |
Float | O elemento ws no início ou no final de s , assina no início de s e o símbolo de ponto decimal (.). O parâmetro s também pode usar notação exponencial. |
Number | O ws , sign , separador de milhares (.) e elementos de vírgula decimal (,). |
Any | Todos os elementos. No entanto, s não pode representar um número hexadecimal. |
O parâmetro s
é analisado usando-se as informações de formatação em um objeto NumberFormatInfo que é inicializado para a cultura do sistema atual. Para obter mais informações, consulte CurrentInfo.
Normalmente, se você passa ao método Double.Parse, uma cadeia de caracteres criada chamando-se o método Double.ToString, o valor Double original é retornado. No entanto, por conta de uma perda de precisão, os valores talvez não sejam iguais. Além disso, tentar analisar a representação de cadeia de caracteres de Double.MinValue ou falha na viagem de ida e Double.MaxValue volta. No .NET Framework e no .NET Core 2.2 e nas versões anteriores, ele lança um OverflowException. No .NET Core 3.0 e versões posteriores, ele retornará Double.NegativeInfinity se você tentar analisar MinValue ou Double.PositiveInfinity se tentar analisar MaxValue. O exemplo a seguir ilustra esse cenário.
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
No .NET Framework e no .NET Core 2.2 e versões anteriores, se s
estiver fora do intervalo do tipo de Double dados, o Parse(String, NumberStyles) método gerará um OverflowException.
No .NET Core 3.0 e versões posteriores, nenhuma exceção é gerada quando s
está fora do intervalo do tipo de Double dados. Na maioria dos casos, o Parse(String, NumberStyles) método retornará Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, há um pequeno conjunto de valores que são considerados mais próximos dos valores máximo ou mínimo de Double do que para infinito positivo ou negativo. Nesses casos, o método retorna Double.MaxValue ou Double.MinValue.
Caso um separador esteja no parâmetro s
durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e NumberGroupSeparator.
Confira também
Aplica-se a
Parse(String, IFormatProvider)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte a representação de cadeia de caracteres de um número em um formato específico da cultura para o número de ponto flutuante de precisão dupla 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
Uma cadeia de caracteres que contém um número a ser convertido.
- provider
- IFormatProvider
Um objeto que fornece informações de formatação específicas de cultura sobre s
.
Retornos
Um número de ponto flutuante de precisão dupla que é equivalente ao valor numérico ou ao símbolo especificado em s
.
Implementações
Exceções
s
é null
.
s
não representa um número em um formato válido.
.NET Framework e .NET Core 2.2 e somente versões anteriores: s
representa um número menor que Double.MinValue ou maior que Double.MaxValue.
Exemplos
O exemplo a seguir é o manipulador de eventos de clique do botão de um formulário da Web. Ele usa a matriz retornada pela propriedade HttpRequest.UserLanguages para determinar a localidade do usuário. Em seguida, ele instancia um objeto CultureInfo que corresponde à localidade. O NumberFormatInfo objeto que pertence a esse CultureInfo objeto é então passado para o Parse(String, IFormatProvider) método para converter a entrada do usuário em um 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
Comentários
No .NET Core 3.0 e posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .NET Framework, a análise de um valor muito grande para representar resultou em falha.
Essa sobrecarga do Parse(String, IFormatProvider) método normalmente é usada para converter texto que pode ser formatado de várias maneiras para um Double valor. Por exemplo, ele pode ser usado para converter o texto inserido por um usuário em uma caixa de texto HTML em um valor numérico.
O parâmetro s
é interpretado usando-se uma combinação dos sinalizadores NumberStyles.Float e NumberStyles.AllowThousands. O s
parâmetro pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolou NumberFormatInfo.NaNSymbol para a cultura especificada por provider
ou pode conter uma cadeia de caracteres do formulário:
[ws] [sign] dígitos integrais[.[dígitos fracionários]] [E[sign]exponential-digits] [ws]
Os elementos opcionais são colocados entre colchetes ([ e ]). Os elementos que contêm o termo "digits" consistem em uma série de caracteres numéricos que varia de 0 a 9.
Elemento | Descrição |
---|---|
ws | Uma série de caracteres de espaço em branco. |
sign | Um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+). |
dígitos integrais | Uma série de dígitos que varia de 0 a 9 que especificam a parte integral do número. Execuções de dígitos integrais podem ser particionadas por um símbolo separador de grupo. Por exemplo, em algumas culturas, uma vírgula (,) separa grupos de milhares. O elemento de dígitos integrais poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários . |
. | Um símbolo de vírgula decimal específico de cultura. |
dígitos fracionários | Uma série de dígitos que varia de 0 a 9 que especificam a parte fracionária do número. |
E | O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). |
dígitos exponenciais | Uma série de dígitos que varia de 0 a 9 que especificam um expoente. |
Para obter mais informações sobre formatos numéricos, consulte o tópico Tipos de Formatação .
O provider
parâmetro é uma implementação IFormatProvider cujo GetFormat método retorna um NumberFormatInfo objeto que fornece informações específicas da cultura usadas na interpretação do formato de s
. Normalmente, é um NumberFormatInfo objeto ou CultureInfo . Se provider
for null
ou não NumberFormatInfo puder ser obtido, as informações de formatação para a cultura atual do sistema serão usadas.
Normalmente, se você passa ao método Double.Parse, uma cadeia de caracteres criada chamando-se o método Double.ToString, o valor Double original é retornado. No entanto, por conta de uma perda de precisão, os valores talvez não sejam iguais. Além disso, tentar analisar a representação de cadeia de caracteres de Double.MinValue ou falha na viagem de ida e Double.MaxValue volta. No .NET Framework e no .NET Core 2.2 e nas versões anteriores, ele lança um OverflowException. No .NET Core 3.0 e versões posteriores, ele retornará Double.NegativeInfinity se você tentar analisar MinValue ou Double.PositiveInfinity se tentar analisar MaxValue. O exemplo a seguir ilustra esse cenário.
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
No .NET Framework e no .NET Core 2.2 e versões anteriores, se s
estiver fora do intervalo do tipo de Double dados, o Parse(String, IFormatProvider) método gerará um OverflowException.
No .NET Core 3.0 e versões posteriores, nenhuma exceção é gerada quando s
está fora do intervalo do tipo de Double dados. Na maioria dos casos, o Parse(String, IFormatProvider) método retornará Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, há um pequeno conjunto de valores que são considerados mais próximos dos valores máximo ou mínimo de Double do que para infinito positivo ou negativo. Nesses casos, o método retorna Double.MaxValue ou Double.MinValue.
Caso um separador esteja no parâmetro s
durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e NumberGroupSeparator.
Confira também
Aplica-se a
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Origem:
- Double.cs
- Origem:
- Double.cs
Analisa um intervalo de caracteres UTF-8 em um 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>
O intervalo de caracteres UTF-8 a serem analisados.
- style
- NumberStyles
Uma combinação bit a bit de estilos numéricos que podem estar presentes em utf8Text
.
- provider
- IFormatProvider
Um objeto que fornece informações de formatação específicas à cultura sobre utf8Text
.
Retornos
O resultado da análise utf8Text
.
Implementações
Aplica-se a
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte um intervalo de caracteres que contém a representação de cadeia de caracteres de um número em um formato específico de cultura e um estilo especificados para o número de ponto flutuante de precisão dupla 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>
Um intervalo de caracteres que contém o número a ser convertido.
- style
- NumberStyles
Uma combinação bit a bit de valores de enumeração que indicam os elementos de estilo que podem estar presentes em s
. Um valor típico para ser especificado é uma combinação de Float com AllowThousands.
- provider
- IFormatProvider
Um objeto que fornece informações de formatação específicas da cultura sobre s
.
Retornos
Um número de ponto flutuante de precisão dupla que é equivalente ao valor numérico ou ao símbolo especificado em s
.
Implementações
Exceções
O s
não representa um valor numérico.
Comentários
No .NET Core 3.0 e posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .NET Framework, a análise de um valor muito grande para representar resultou em falha.
Se s
estiver fora do intervalo do tipo de Double dados, o método retornará Double.NegativeInfinity se s
for menor que Double.MinValue e Double.PositiveInfinity se s
for maior que Double.MaxValue.
Aplica-se a
Parse(String, NumberStyles, IFormatProvider)
- Origem:
- Double.cs
- Origem:
- Double.cs
- Origem:
- Double.cs
Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo para o número de ponto flutuante de precisão dupla equivalente.
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
Uma cadeia de caracteres que contém um número a ser convertido.
- style
- NumberStyles
Uma combinação bit a bit de valores de enumeração que indicam os elementos de estilo que podem estar presentes em s
. Um valor típico para ser especificado é uma combinação de Float com AllowThousands.
- provider
- IFormatProvider
Um objeto que fornece informações de formatação específicas da cultura sobre s
.
Retornos
Um número de ponto flutuante de precisão dupla que é equivalente ao valor numérico ou ao símbolo especificado em s
.
Implementações
Exceções
s
é null
.
O s
não representa um valor numérico.
.NET Framework e .NET Core 2.2 e somente versões anteriores: s
representa um número menor que Double.MinValue ou maior que Double.MaxValue.
Exemplos
O exemplo a seguir ilustra o uso do Parse(String, NumberStyles, IFormatProvider) método para atribuir várias representações de cadeia de caracteres de valores de temperatura a um 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
Comentários
No .NET Core 3.0 e posteriores, os valores que são muito grandes para representar são arredondados para PositiveInfinity ou NegativeInfinity conforme exigido pela especificação IEEE 754. Em versões anteriores, incluindo .NET Framework, a análise de um valor muito grande para representar resultou em falha.
O parâmetro style
define os elementos de estilo (como espaço em branco, separadores de milhares e símbolos de moeda) que são permitidos no parâmetro s
para que a operação de análise seja bem-sucedida. Ele deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Os seguintes membros NumberStyles não são suportados:
O s
parâmetro pode conter NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolou NumberFormatInfo.NaNSymbol para a cultura especificada por provider
. Dependendo do valor de style
, ele também pode assumir a forma:
[ws] [$] [sign][integral-digits,]integral-digits[.[ dígitos fracionários]] [E[sign]exponential-digits] [ws]
Elementos emoldurados em colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.
Elemento | Descrição |
---|---|
ws | Uma série de caracteres de espaço em branco. Espaço em branco pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingWhite e pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingWhite. |
$ | Um símbolo de moeda específico de cultura. A posição na cadeia de caracteres é definida pelas propriedades NumberFormatInfo.CurrencyNegativePattern e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo de moeda da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowCurrencySymbol. |
sign | Um símbolo de sinal negativo (-) ou um símbolo de sinal positivo (+). O sinal pode ser exibido no início de s caso style inclua o sinalizador NumberStyles.AllowLeadingSign e ele pode ser exibido no final de s caso style inclua o sinalizador NumberStyles.AllowTrailingSign. Os parênteses podem ser usados em s para indicar um valor negativo caso style inclua o sinalizador NumberStyles.AllowParentheses. |
dígitos integrais | Uma série de dígitos que varia de 0 a 9 que especificam a parte integral do número. O elemento de dígitos integrais poderá estar ausente se a cadeia de caracteres contiver o elemento de dígitos fracionários . |
, | Um separador de grupo específico de cultura. O símbolo do separador do grupo da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowThousands |
. | Um símbolo de vírgula decimal específico de cultura. O símbolo da vírgula decimal da cultura atual pode ser exibido em s caso style inclua o sinalizador NumberStyles.AllowDecimalPoint. |
dígitos fracionários | Uma série de dígitos que varia de 0 a 9 que especificam a parte fracionária do número. Os dígitos fracionários podem ser exibidos em s caso style inclua o sinalizador NumberStyles.AllowDecimalPoint. |
E | O caractere "e" ou "E", que indica que o valor é representado em notação exponencial (científica). O parâmetro s pode representar um número em notação exponencial caso style inclua o sinalizador NumberStyles.AllowExponent. |
dígitos exponenciais | Uma série de dígitos que varia de 0 a 9 que especificam um expoente. |
Observação
Todos os caracteres NUL de terminação (U+0000) no s
são ignorados pela operação de análise, independentemente do valor do style
argumento.
Uma cadeia de caracteres apenas com dígitos (que corresponde ao estilo NumberStyles.None ) sempre é analisada com Double êxito. Os elementos de controle dos membros System.Globalization.NumberStyles restantes que podem estar presentes, mas que não precisam estar presentes, na cadeia de caracteres de entrada. A tabela a seguir indica como os sinalizadores individuais NumberStyles afetam os elementos que podem estar presentes em s
.
Valor NumberStyles | Elementos permitidos em s além de dígitos |
---|---|
None | Somente o elemento de dígitos integrais . |
AllowDecimalPoint | Os elementos de ponto decimal (.) e de dígitos fracionários . |
AllowExponent | O caractere "e" ou "E", que indica a notação exponencial. Esse sinalizador por si só dá suporte a valores nos dígitosde formulário Edígitos; sinalizadores adicionais são necessários para analisar com êxito cadeias de caracteres com elementos como sinais positivos ou negativos e símbolos de ponto decimal. |
AllowLeadingWhite | O elemento ws no início de s . |
AllowTrailingWhite | O elemento ws no final de s . |
AllowLeadingSign | O elemento sinal no início de s . |
AllowTrailingSign | O elemento sinal no final de s . |
AllowParentheses | O elemento sinal na forma de parênteses que incluem o valor numérico. |
AllowThousands | O elemento separador de milhares (.). |
AllowCurrencySymbol | O elemento de moeda ($). |
Currency | Todos os elementos. No entanto, s não pode representar um número hexadecimal ou um número em notação exponencial. |
Float | O elemento ws no início ou no final de s , assina no início de s e o símbolo de ponto decimal (.). O parâmetro s também pode usar notação exponencial. |
Number | O ws , sign , separador de milhares (.) e elementos de vírgula decimal (,). |
Any | Todos os elementos. No entanto, s não pode representar um número hexadecimal. |
O provider
parâmetro é uma implementação IFormatProvider cujo GetFormat método retorna um NumberFormatInfo objeto que fornece informações específicas da cultura usadas na interpretação do formato de s
. Normalmente, é um NumberFormatInfo objeto ou CultureInfo . Se provider
for null
ou não NumberFormatInfo puder ser obtido, as informações de formatação para a cultura atual do sistema serão usadas.
Normalmente, se você passa ao método Double.Parse, uma cadeia de caracteres criada chamando-se o método Double.ToString, o valor Double original é retornado. No entanto, por conta de uma perda de precisão, os valores talvez não sejam iguais. Além disso, tentar analisar a representação de cadeia de caracteres de MinValue ou falha na viagem de ida e Double.MaxValue volta. No .NET Framework e no .NET Core 2.2 e nas versões anteriores, ele lança um OverflowException. No .NET Core 3.0 e versões posteriores, ele retornará Double.NegativeInfinity se você tentar analisar MinValue ou Double.PositiveInfinity se tentar analisar MaxValue. O exemplo a seguir ilustra esse cenário.
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
No .NET Framework e no .NET Core 2.2 e versões anteriores, se s
estiver fora do intervalo do tipo de Double dados, o Parse(String, NumberStyles, IFormatProvider) método gerará um OverflowException.
No .NET Core 3.0 e versões posteriores, nenhuma exceção é gerada quando s
está fora do intervalo do tipo de Double dados. Na maioria dos casos, o Parse(String, NumberStyles, IFormatProvider) método retornará Double.PositiveInfinity ou Double.NegativeInfinity. No entanto, há um pequeno conjunto de valores que são considerados mais próximos dos valores máximo ou mínimo de Double do que para infinito positivo ou negativo. Nesses casos, o método retorna Double.MaxValue ou Double.MinValue.
Caso um separador esteja no parâmetro s
durante uma operação de análise e a moeda aplicável ou os separadores de casa decimal e grupo sejam iguais, a operação de análise pressupõe que o separador seja um separador decimal, e não um separador de grupo. Para obter mais informações sobre separadores, consulte CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparator e NumberGroupSeparator.
Confira também
Aplica-se a
Comentários
https://aka.ms/ContentUserFeedback.
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja:Submeter e ver comentários