Single.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 en forma de cadena de un número en el número de punto flotante de precisión sencilla equivalente.
Sobrecargas
Parse(String, NumberStyles, IFormatProvider) |
Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión sencilla equivalente. |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Convierte el intervalo de caracteres que contiene la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en el número de punto flotante de precisión sencilla equivalente. |
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Analiza un intervalo de caracteres UTF-8 en un valor. |
Parse(String, IFormatProvider) |
Convierte la representación en forma de cadena de un número con un formato específico de la referencia cultural especificado en el número de punto flotante de precisión sencilla equivalente. |
Parse(String) |
Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión sencilla equivalente. |
Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analiza un intervalo de caracteres en un valor. |
Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Analiza un intervalo de caracteres UTF-8 en un valor. |
Parse(String, NumberStyles) |
Convierte la representación en forma de cadena de un número con un estilo especificado en el número de punto flotante de precisión sencilla equivalente. |
Comentarios
En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, analizar un valor demasiado grande para representar se produjo un error.
Parse(String, NumberStyles, IFormatProvider)
- Source:
- Single.cs
- Source:
- Single.cs
- Source:
- Single.cs
Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión sencilla equivalente.
public:
static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<float>::Parse;
public static float Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static float Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> single
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Single
Parámetros
- s
- String
Cadena que contiene un número que se va a convertir.
- style
- NumberStyles
Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s
. Un valor que se especifica de forma habitual es Float combinado con AllowThousands.
- provider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural acerca de s
.
Devoluciones
Número de punto flotante de precisión sencilla 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 Single.MinValue o mayor que Single.MaxValue.
Ejemplos
En el ejemplo de código siguiente se usa el Parse(String, NumberStyles, IFormatProvider) método para analizar las representaciones de cadena de Single los valores. Cada cadena de una matriz se analiza mediante las convenciones de formato de en-US, nl-NL y una referencia cultural personalizada. La referencia cultural personalizada define su símbolo separador de grupo como el carácter de subrayado ("_") y su tamaño de grupo como dos.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
// Define an array of string values.
string[] values = { " 987.654E-2", " 987,654E-2", "(98765,43210)",
"9,876,543.210", "9.876.543,210", "98_76_54_32,19" };
// Create a custom culture based on the invariant culture.
CultureInfo ci = new CultureInfo("");
ci.NumberFormat.NumberGroupSizes = new int[] { 2 };
ci.NumberFormat.NumberGroupSeparator = "_";
// Define an array of format providers.
CultureInfo[] providers = { new CultureInfo("en-US"),
new CultureInfo("nl-NL"), ci };
// Define an array of styles.
NumberStyles[] styles = { NumberStyles.Currency, NumberStyles.Float };
// Iterate the array of format providers.
foreach (CultureInfo provider in providers)
{
Console.WriteLine("Parsing using the {0} culture:",
provider.Name == String.Empty ? "Invariant" : provider.Name);
// Parse each element in the array of string values.
foreach (string value in values)
{
foreach (NumberStyles style in styles)
{
try {
float number = Single.Parse(value, style, provider);
Console.WriteLine(" {0} ({1}) -> {2}",
value, style, number);
}
catch (FormatException) {
Console.WriteLine(" '{0}' is invalid using {1}.", value, style);
}
catch (OverflowException) {
Console.WriteLine(" '{0}' is out of the range of a Single.", value);
}
}
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// Parsing using the en-US culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the nl-NL culture:
// ' 987.654E-2' is invalid using Currency.
// ' 987.654E-2' is invalid using Float.
// ' 987,654E-2' is invalid using Currency.
// 987,654E-2 (Float) -> 9.87654
// (98765,43210) (Currency) -> -98765.43
// '(98765,43210)' is invalid using Float.
// '9,876,543.210' is invalid using Currency.
// '9,876,543.210' is invalid using Float.
// 9.876.543,210 (Currency) -> 9876543
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the Invariant culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// 98_76_54_32,19 (Currency) -> 9.876543E+09
// '98_76_54_32,19' is invalid using Float.
open System
open System.Globalization
// Define a list of string values.
let values =
[ " 987.654E-2"; " 987,654E-2"; "(98765,43210)"
"9,876,543.210"; "9.876.543,210"; "98_76_54_32,19" ]
// Create a custom culture based on the invariant culture.
let ci = CultureInfo ""
ci.NumberFormat.NumberGroupSizes <- [| 2 |]
ci.NumberFormat.NumberGroupSeparator <- "_"
// Define a list of format providers.
let providers =
[ CultureInfo "en-US"
CultureInfo "nl-NL"
ci ]
// Define a list of styles.
let styles = [ NumberStyles.Currency; NumberStyles.Float ]
// Iterate the list of format providers.
for provider in providers do
printfn $"""Parsing using the {if provider.Name = String.Empty then "Invariant" else provider.Name} culture:"""
// Parse each element in the array of string values.
for value in values do
for style in styles do
try
let number = Single.Parse(value, style, provider)
printfn $" {value} ({style}) -> {number}"
with
| :? FormatException ->
printfn $" '{value}' is invalid using {style}."
| :? OverflowException ->
printfn $" '{value}' is out of the range of a Single."
printfn ""
// The example displays the following output:
// Parsing using the en-US culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the nl-NL culture:
// ' 987.654E-2' is invalid using Currency.
// ' 987.654E-2' is invalid using Float.
// ' 987,654E-2' is invalid using Currency.
// 987,654E-2 (Float) -> 9.87654
// (98765,43210) (Currency) -> -98765.43
// '(98765,43210)' is invalid using Float.
// '9,876,543.210' is invalid using Currency.
// '9,876,543.210' is invalid using Float.
// 9.876.543,210 (Currency) -> 9876543
// '9.876.543,210' is invalid using Float.
// '98_76_54_32,19' is invalid using Currency.
// '98_76_54_32,19' is invalid using Float.
//
// Parsing using the Invariant culture:
// ' 987.654E-2' is invalid using Currency.
// 987.654E-2 (Float) -> 9.87654
// ' 987,654E-2' is invalid using Currency.
// ' 987,654E-2' is invalid using Float.
// (98765,43210) (Currency) -> -9.876543E+09
// '(98765,43210)' is invalid using Float.
// 9,876,543.210 (Currency) -> 9876543
// '9,876,543.210' is invalid using Float.
// '9.876.543,210' is invalid using Currency.
// '9.876.543,210' is invalid using Float.
// 98_76_54_32,19 (Currency) -> 9.876543E+09
// '98_76_54_32,19' is invalid using Float.
Imports System.Globalization
Module Example
Public Sub Main()
' Define an array of string values.
Dim values() As String = { " 987.654E-2", " 987,654E-2", _
"(98765,43210)", "9,876,543.210", _
"9.876.543,210", "98_76_54_32,19" }
' Create a custom culture based on the invariant culture.
Dim ci As New CultureInfo("")
ci.NumberFormat.NumberGroupSizes = New Integer() { 2 }
ci.NumberFormat.NumberGroupSeparator = "_"
' Define an array of format providers.
Dim providers() As CultureInfo = { New CultureInfo("en-US"), _
New CultureInfo("nl-NL"), ci }
' Define an array of styles.
Dim styles() As NumberStyles = { NumberStyles.Currency, NumberStyles.Float }
' Iterate the array of format providers.
For Each provider As CultureInfo In providers
Console.WriteLine("Parsing using the {0} culture:", _
If(provider.Name = String.Empty, "Invariant", provider.Name))
' Parse each element in the array of string values.
For Each value As String In values
For Each style As NumberStyles In styles
Try
Dim number As Single = Single.Parse(value, style, provider)
Console.WriteLine(" {0} ({1}) -> {2}", _
value, style, number)
Catch e As FormatException
Console.WriteLine(" '{0}' is invalid using {1}.", value, style)
Catch e As OverflowException
Console.WriteLine(" '{0}' is out of the range of a Single.", value)
End Try
Next
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' Parsing using the en-US culture:
' ' 987.654E-2' is invalid using Currency.
' 987.654E-2 (Float) -> 9.87654
' ' 987,654E-2' is invalid using Currency.
' ' 987,654E-2' is invalid using Float.
' (98765,43210) (Currency) -> -9.876543E+09
' '(98765,43210)' is invalid using Float.
' 9,876,543.210 (Currency) -> 9876543
' '9,876,543.210' is invalid using Float.
' '9.876.543,210' is invalid using Currency.
' '9.876.543,210' is invalid using Float.
' '98_76_54_32,19' is invalid using Currency.
' '98_76_54_32,19' is invalid using Float.
'
' Parsing using the nl-NL culture:
' ' 987.654E-2' is invalid using Currency.
' ' 987.654E-2' is invalid using Float.
' ' 987,654E-2' is invalid using Currency.
' 987,654E-2 (Float) -> 9.87654
' (98765,43210) (Currency) -> -98765.43
' '(98765,43210)' is invalid using Float.
' '9,876,543.210' is invalid using Currency.
' '9,876,543.210' is invalid using Float.
' 9.876.543,210 (Currency) -> 9876543
' '9.876.543,210' is invalid using Float.
' '98_76_54_32,19' is invalid using Currency.
' '98_76_54_32,19' is invalid using Float.
'
' Parsing using the Invariant culture:
' ' 987.654E-2' is invalid using Currency.
' 987.654E-2 (Float) -> 9.87654
' ' 987,654E-2' is invalid using Currency.
' ' 987,654E-2' is invalid using Float.
' (98765,43210) (Currency) -> -9.876543E+09
' '(98765,43210)' is invalid using Float.
' 9,876,543.210 (Currency) -> 9876543
' '9,876,543.210' is invalid using Float.
' '9.876.543,210' is invalid using Currency.
' '9.876.543,210' is invalid using Float.
' 98_76_54_32,19 (Currency) -> 9.876543E+09
' '98_76_54_32,19' is invalid using Float.
Comentarios
En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.
El style
parámetro define los elementos de estilo (como espacios en blanco, separadores de miles y símbolos de moneda) que se permiten en el s
parámetro para que la operación de análisis se realice correctamente. Debe ser una combinación de marcas de bits de la NumberStyles enumeración. No se admiten los siguientes NumberStyles miembros:
El s
parámetro puede contener NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol para la referencia cultural especificada por provider
. Dependiendo del valor de style
, también puede tomar la forma:
[ws] [] [$sign][integral-digits,]integral-digits[.[ fracciones de dígitos]] [E[sign]exponencial-digits] [ws]
Los elementos enmarcados entre corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.
Elemento | Descripción |
---|---|
ws | Una serie de caracteres de espacio en blanco. El espacio en blanco puede aparecer al principio de s si incluye la NumberStyles.AllowLeadingWhite marca y puede aparecer al final de s si style incluye la NumberStyles.AllowTrailingWhitestyle marca. |
$ | Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las NumberFormatInfo.CurrencyNegativePattern propiedades y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural actual. El símbolo de moneda de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowCurrencySymbol marca . |
sign | Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). El signo puede aparecer al principio de s si incluye la NumberStyles.AllowLeadingSign marca y puede aparecer al final de s si style incluye la NumberStyles.AllowTrailingSignstyle marca. Los paréntesis se pueden usar en s para indicar un valor negativo si style incluye la NumberStyles.AllowParentheses marca . |
dígitos enteros | Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fracciones de dígitos . |
, | Separador de grupo específico de la referencia cultural. El símbolo separador de grupo de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowThousands marca . |
. | Símbolo de separador decimal específico de la referencia cultural. El símbolo de separador decimal de la referencia cultural actual puede aparecer en s si style incluye la NumberStyles.AllowDecimalPoint marca . |
fracciones de dígitos | Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número. Los dígitos fraccionarios pueden aparecer en s si style incluye la NumberStyles.AllowDecimalPoint marca . |
E | El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El s parámetro puede representar un número en notación exponencial si style incluye la NumberStyles.AllowExponent marca . |
dígitos exponenciales | Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente. |
Nota
La operación de análisis omite todos los caracteres NUL (U+0000) de s
, independientemente del valor del style
argumento.
Una cadena solo con dígitos (que corresponde al NumberStyles.None estilo) siempre analiza correctamente si está en el intervalo del Single tipo. Los miembros restantes System.Globalization.NumberStyles controlan los elementos que pueden estar presentes, pero no son necesarios para estar presentes, en la cadena de entrada. En la tabla siguiente se indica cómo afectan las marcas individuales NumberStyles a los elementos que pueden estar presentes en s
.
Valor NumberStyles | Elementos permitidos además s de dígitos |
---|---|
None | Solo el elemento integral-digits . |
AllowDecimalPoint | Elementos decimales (.) y fracciones de dígitos . |
AllowExponent | El carácter "e" o "E", que indica la notación exponencial. Esta marca por sí misma admite valores en los dígitosde formaE digits; se necesitan marcas adicionales para analizar correctamente cadenas con elementos como signos positivos o negativos y símbolos decimales. |
AllowLeadingWhite | Elemento ws al principio de s . |
AllowTrailingWhite | Elemento ws al final de s . |
AllowLeadingSign | Elemento sign al principio de s . |
AllowTrailingSign | Elemento sign al final de s . |
AllowParentheses | Elemento de signo en forma de paréntesis que incluye el valor numérico. |
AllowThousands | Elemento separador de miles (,). |
AllowCurrencySymbol | Elemento currency ($). |
Currency | Todos los elementos. Sin embargo, s no puede representar un número hexadecimal o un número en notación exponencial. |
Float | Elemento ws al principio o al final de s , signo al principio de s y el símbolo decimal (.). El s parámetro también puede usar la notación exponencial. |
Number | Los ws elementos separadores , sign , miles (,) y decimal point (.). |
Any | Todos los elementos. Sin embargo, s no puede representar un número hexadecimal. |
El provider
parámetro es una IFormatProvider implementación. Su GetFormat método devuelve un NumberFormatInfo objeto que proporciona información específica de la referencia cultural sobre el formato de value
. Normalmente, provider
puede ser cualquiera de los siguientes:
Objeto CultureInfo que representa la referencia cultural que proporciona información de formato numérico. Su GetFormat método devuelve el NumberFormatInfo objeto que proporciona información de formato numérico.
Objeto NumberFormatInfo que proporciona información de formato. (Su implementación de GetFormat solo devuelve a sí mismo).
Objeto personalizado que implementa IFormatProvider y usa el GetFormat método para crear instancias y devolver el NumberFormatInfo objeto que proporciona información de formato.
Si provider
es null
, se usa el NumberFormatInfo objeto de la referencia cultural actual.
Si s
está fuera del intervalo del tipo de Single datos, el método produce una OverflowException excepción en .NET Framework y .NET Core 2.2 y versiones anteriores. En .NET Core 3.0 y versiones posteriores, devuelve Single.NegativeInfinity si s
es menor que Single.MinValue y Single.PositiveInfinity si s
es mayor que Single.MaxValue.
Si se encuentra un separador en el s
parámetro durante una operación de análisis y los separadores decimales y de grupo aplicables son iguales, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.
Consulte también
Se aplica a
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Source:
- Single.cs
- Source:
- Single.cs
- Source:
- Single.cs
Convierte el intervalo de caracteres que contiene la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en el número de punto flotante de precisión sencilla equivalente.
public static float Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);
public static float 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 -> single
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 Single
Parámetros
- s
- ReadOnlySpan<Char>
Un intervalo de caracteres que contiene el número que se va a convertir.
- style
- NumberStyles
Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s
. Un valor que se especifica de forma habitual es Float combinado con AllowThousands.
- provider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural acerca de s
.
Devoluciones
Número de punto flotante de precisión sencilla 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 lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, analizar un valor demasiado grande para representar se produjo un error.
Si s
está fuera del intervalo del Single tipo de datos, el método devuelve Single.NegativeInfinity si s
es menor que Single.MinValue y Single.PositiveInfinity si s
es mayor que Single.MaxValue.
Se aplica a
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Source:
- Single.cs
- Source:
- Single.cs
Analiza un intervalo de caracteres UTF-8 en un valor.
public static float 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 -> single
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 Single
Parámetros
- utf8Text
- ReadOnlySpan<Byte>
Intervalo de caracteres UTF-8 que se van a analizar.
- style
- NumberStyles
Combinación bit a bit de estilos de número que pueden estar presentes en utf8Text
.
- provider
- IFormatProvider
Un objeto que proporciona información de formato específica de la referencia cultural sobre utf8Text
.
Devoluciones
Resultado del análisis utf8Text
de .
Implementaciones
Se aplica a
Parse(String, IFormatProvider)
- Source:
- Single.cs
- Source:
- Single.cs
- Source:
- Single.cs
Convierte la representación en forma de cadena de un número con un formato específico de la referencia cultural especificado en el número de punto flotante de precisión sencilla equivalente.
public:
static float Parse(System::String ^ s, IFormatProvider ^ provider);
public:
static float Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<float>::Parse;
public static float Parse (string s, IFormatProvider provider);
public static float Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> single
Public Shared Function Parse (s As String, provider As IFormatProvider) As Single
Parámetros
- s
- String
Cadena que contiene un número que se va a convertir.
- provider
- IFormatProvider
Objeto que proporciona información de formato específica de la referencia cultural acerca de s
.
Devoluciones
Número de punto flotante de precisión sencilla equivalente al valor numérico o símbolo especificado en s
.
Implementaciones
Excepciones
s
es null
.
s
no representa un número con un formato válido.
.NET Framework y .NET Core 2.2 y versiones anteriores solo: s
representa un número menor que Single.MinValue o mayor que Single.MaxValue.
Ejemplos
El ejemplo siguiente es el controlador de eventos de clic de botón de un formulario web. Usa la matriz devuelta por la HttpRequest.UserLanguages propiedad para determinar la configuración regional del usuario. A continuación, crea una instancia de un CultureInfo objeto que corresponde a esa configuración regional. A NumberFormatInfo continuación, el objeto que pertenece a ese CultureInfo objeto se pasa al Parse(String, IFormatProvider) método para convertir la entrada del usuario en un Single valor.
protected void OkToSingle_Click(object sender, EventArgs e)
{
string locale;
float 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 = Single.Parse(this.inputNumber.Text, culture.NumberFormat);
}
catch (FormatException)
{
return;
}
catch (Exception)
{
return;
}
// Output number to label on web form
this.outputNumber.Text = "Number is " + number.ToString();
}
Protected Sub OkToSingle_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToSingle.Click
Dim locale As String
Dim culture As CultureInfo
Dim number As Single
' 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 = Single.Parse(Me.inputNumber.Text, culture.NumberFormat)
Catch ex As FormatException
Exit Sub
Catch ex As OverflowException
Exit Sub
End Try
' Output number to label on web form
Me.outputNumber.Text = "Number is " & number.ToString()
End Sub
Comentarios
En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, analizar un valor demasiado grande para representar se produjo un error.
Esta sobrecarga se usa normalmente para convertir texto que se puede dar formato de varias maneras a un Single valor. Por ejemplo, se puede usar para convertir el texto escrito por un usuario en un cuadro de texto HTML en un valor numérico.
El s
parámetro se interpreta mediante una combinación de las NumberStyles.Float marcas y NumberStyles.AllowThousands . El s
parámetro puede contener NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol para la referencia cultural especificada por provider
, o puede contener una cadena del formulario:
[ws] [sign] dígitos enteros[.[fracciones de dígitos]] [E[sign]exponential-digits] [ws]
Los elementos opcionales están enmarcados entre corchetes ([ y ]). Los elementos que contienen el término "dígitos" constan de una serie de caracteres numéricos comprendidos entre 0 y 9.
Elemento | Descripción |
---|---|
ws | Una serie de caracteres de espacio en blanco. |
sign | Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). |
dígitos enteros | Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. Las ejecuciones de dígitos enteros se pueden particionar mediante un símbolo separador de grupo. Por ejemplo, en algunas referencias culturales, una coma (,) separa grupos de miles. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fractional-digits . |
. | Símbolo de separador decimal específico de la referencia cultural. |
fracciones de dígitos | Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número. |
E | Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). |
dígitos exponenciales | Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente. |
Para obtener más información sobre los formatos numéricos, vea el tema Tipos de formato .
El provider
parámetro es una IFormatProvider implementación cuyo GetFormat método devuelve un NumberFormatInfo objeto que proporciona información de formato específica de la referencia cultural. Cuando se invoca el Parse(String, IFormatProvider) método , llama al provider
método del GetFormat parámetro y lo pasa un Type objeto que representa el NumberFormatInfo tipo. A GetFormat continuación, el método devuelve el NumberFormatInfo objeto que proporciona información sobre el formato del s
parámetro . Hay tres maneras de usar el provider
parámetro para proporcionar información de formato personalizada a la operación de análisis:
Puede pasar un CultureInfo objeto que representa la referencia cultural que proporciona información de formato. Su GetFormat método devuelve el NumberFormatInfo objeto que proporciona información de formato numérico para esa referencia cultural.
Puede pasar el objeto real NumberFormatInfo que proporciona información de formato numérico. (Su implementación de GetFormat solo devuelve a sí mismo).
Puede pasar un objeto personalizado que implemente IFormatProvider. Su GetFormat método crea una instancia de y devuelve el NumberFormatInfo objeto que proporciona información de formato.
Si provider
es null
o NumberFormatInfo no se puede obtener, se usa la información de formato de la referencia cultural del sistema actual.
Si s
está fuera del intervalo del tipo de Single datos, el método produce una OverflowException excepción en .NET Framework y .NET Core 2.2 y versiones anteriores. En .NET Core 3.0 y versiones posteriores, devuelve Single.NegativeInfinity si s
es menor que Single.MinValue y Single.PositiveInfinity si s
es mayor que Single.MaxValue.
Si se encuentra un separador en el s
parámetro durante una operación de análisis y los separadores decimales y de grupo aplicables son iguales, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.
Algunos ejemplos de s
son "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" y "-Infinity".
Consulte también
Se aplica a
Parse(String)
- Source:
- Single.cs
- Source:
- Single.cs
- Source:
- Single.cs
Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión sencilla equivalente.
public:
static float Parse(System::String ^ s);
public static float Parse (string s);
static member Parse : string -> single
Public Shared Function Parse (s As String) As Single
Parámetros
- s
- String
Cadena que contiene un número que se va a convertir.
Devoluciones
Número de punto flotante de precisión sencilla equivalente al valor numérico o símbolo especificado en s
.
Excepciones
s
es null
.
s
no representa un número con un formato válido.
.NET Framework y .NET Core 2.2 y versiones anteriores solo: s
representa un número menor que Single.MinValue o mayor que Single.MaxValue.
Ejemplos
En el ejemplo siguiente se usa el Parse(String) método para convertir una matriz de cadenas en valores equivalentes Single .
using System;
public class Example
{
public static void Main()
{
string[] values = { "100", "(100)", "-123,456,789", "123.45e+6",
"+500", "5e2", "3.1416", "600.", "-.123",
"-Infinity", "-1E-16", Double.MaxValue.ToString(),
Single.MinValue.ToString(), String.Empty };
foreach (string value in values)
{
try {
float number = Single.Parse(value);
Console.WriteLine("{0} -> {1}", value, number);
}
catch (FormatException) {
Console.WriteLine("'{0}' is not in a valid format.", value);
}
catch (OverflowException) {
Console.WriteLine("{0} is outside the range of a Single.", value);
}
}
}
}
// The example displays the following output:
// 100 -> 100
// '(100)' is not in a valid format.
// -123,456,789 -> -1.234568E+08
// 123.45e+6 -> 1.2345E+08
// +500 -> 500
// 5e2 -> 500
// 3.1416 -> 3.1416
// 600. -> 600
// -.123 -> -0.123
// -Infinity -> -Infinity
// -1E-16 -> -1E-16
// 1.79769313486232E+308 is outside the range of a Single.
// -3.402823E+38 -> -3.402823E+38
// '' is not in a valid format.
open System
let values =
[| "100"; "(100)"; "-123,456,789"; "123.45e+6"
"+500"; "5e2"; "3.1416"; "600."; "-.123"
"-Infinity"; "-1E-16"; string Double.MaxValue
string Single.MinValue; String.Empty |]
for value in values do
try
let number = Single.Parse value
printfn $"{value} -> {number}"
with
| :? FormatException ->
printfn $"'{value}' is not in a valid format."
| :? OverflowException ->
printfn $"{value} is outside the range of a Single."
// The example displays the following output:
// 100 -> 100
// '(100)' is not in a valid format.
// -123,456,789 -> -1.234568E+08
// 123.45e+6 -> 1.2345E+08
// +500 -> 500
// 5e2 -> 500
// 3.1416 -> 3.1416
// 600. -> 600
// -.123 -> -0.123
// -Infinity -> -Infinity
// -1E-16 -> -1E-16
// 1.79769313486232E+308 is outside the range of a Single.
// -3.402823E+38 -> -3.402823E+38
// '' is not in a valid format.
Module Example
Public Sub Main()
Dim values() As String = { "100", "(100)", "-123,456,789", "123.45e+6", _
"+500", "5e2", "3.1416", "600.", "-.123", _
"-Infinity", "-1E-16", Double.MaxValue.ToString(), _
Single.MinValue.ToString(), String.Empty }
For Each value As String In values
Try
Dim number As Single = Single.Parse(value)
Console.WriteLine("{0} -> {1}", value, number)
Catch e As FormatException
Console.WriteLine("'{0}' is not in a valid format.", value)
Catch e As OverflowException
Console.WriteLine("{0} is outside the range of a Single.", value)
End Try
Next
End Sub
End Module
' The example displays the following output:
' 100 -> 100
' '(100)' is not in a valid format.
' -123,456,789 -> -1.234568E+08
' 123.45e+6 -> 1.2345E+08
' +500 -> 500
' 5e2 -> 500
' 3.1416 -> 3.1416
' 600. -> 600
' -.123 -> -0.123
' -Infinity -> -Infinity
' -1E-16 -> -1E-16
' 1.79769313486232E+308 is outside the range of a Single.
' -3.402823E+38 -> -3.402823E+38
' '' is not in a valid format.
Comentarios
En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, analizar un valor demasiado grande para representar se produjo un error.
El s
parámetro puede contener la referencia cultural actual PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolo una cadena del formulario:
[ws] [sign] [entero-digits[,]] dígitos enteros[.[fracciones de dígitos]] [e[sign]exponential-digits] [ws]
Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.
Elemento | Descripción |
---|---|
ws | Una serie de caracteres de espacio en blanco. |
sign | Un símbolo de signo negativo o un símbolo de signo positivo. Los caracteres de signo válidos se determinan mediante las NumberFormatInfo.NegativeSign propiedades y NumberFormatInfo.PositiveSign de la referencia cultural actual. Solo se puede usar un signo inicial. |
dígitos enteros | Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. Las ejecuciones de dígitos enteros se pueden particionar mediante un símbolo separador de grupo. Por ejemplo, en algunas referencias culturales, una coma (,) separa grupos de miles. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fracciones de dígitos . |
, | Símbolo separador de miles específico de la referencia cultural. |
. | Símbolo de separador decimal específico de la referencia cultural. |
fracciones de dígitos | Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número. |
E | El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). |
dígitos exponenciales | Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente. |
El s
parámetro se interpreta mediante una combinación de las NumberStyles.Float marcas y NumberStyles.AllowThousands . Esto significa que se permiten espacios en blanco y separadores de miles, pero no se admiten símbolos de moneda. Para definir explícitamente los elementos (como símbolos de moneda, separadores de miles y espacios en blanco) que pueden estar presentes en s
, use la sobrecarga del Parse(String, NumberStyles) método .
El s
parámetro se analiza mediante la información de formato de un NumberFormatInfo objeto que se inicializa para la referencia cultural del sistema actual. Para obtener más información, vea CurrentInfo. Para analizar una cadena mediante la información de formato de una referencia cultural específica, use el Parse(String, IFormatProvider) método o Parse(String, NumberStyles, IFormatProvider) .
Normalmente, si pasa el Parse método una cadena que se crea llamando al ToString método , se devuelve el valor original Single . Sin embargo, debido a una pérdida de precisión, es posible que los valores no sean iguales.
Si s
está fuera del intervalo del tipo de Single datos, el método inicia un OverflowException en .NET Framework y .NET Core 2.2 y versiones anteriores. En .NET Core 3.0 y versiones posteriores, devuelve Single.NegativeInfinity si s
es menor que Single.MinValue y Single.PositiveInfinity si s
es mayor que Single.MaxValue.
Si se encuentra un separador en el s
parámetro durante una operación de análisis y los separadores decimales y de número y número aplicables son los mismos, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.
Consulte también
Se aplica a
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Source:
- Single.cs
- Source:
- Single.cs
- Source:
- Single.cs
Analiza un intervalo de caracteres en un valor.
public:
static float Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<float>::Parse;
public static float Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> single
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Single
Parámetros
- s
- ReadOnlySpan<Char>
Intervalo de caracteres que se van a analizar.
- provider
- IFormatProvider
Un objeto que proporciona información de formato específica de la referencia cultural sobre s
.
Devoluciones
Resultado del análisis s
de .
Implementaciones
Se aplica a
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Source:
- Single.cs
- Source:
- Single.cs
Analiza un intervalo de caracteres UTF-8 en un valor.
public:
static float Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<float>::Parse;
public static float Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> single
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Single
Parámetros
- utf8Text
- ReadOnlySpan<Byte>
Intervalo de caracteres UTF-8 que se van a analizar.
- provider
- IFormatProvider
Un objeto que proporciona información de formato específica de la referencia cultural sobre utf8Text
.
Devoluciones
Resultado del análisis utf8Text
de .
Implementaciones
Se aplica a
Parse(String, NumberStyles)
- Source:
- Single.cs
- Source:
- Single.cs
- Source:
- Single.cs
Convierte la representación en forma de cadena de un número con un estilo especificado en el número de punto flotante de precisión sencilla equivalente.
public:
static float Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static float Parse (string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> single
Public Shared Function Parse (s As String, style As NumberStyles) As Single
Parámetros
- s
- String
Cadena que contiene un número que se va a convertir.
- style
- NumberStyles
Combinación bit a bit de los valores de enumeración que indica los elementos de estilo que pueden estar presentes en s
. Un valor que se especifica de forma habitual es Float combinado con AllowThousands.
Devoluciones
Número de punto flotante de precisión sencilla equivalente al valor numérico o símbolo especificado en s
.
Excepciones
s
es null
.
s
no es un número con un formato válido.
.NET Framework y .NET Core 2.2 y versiones anteriores solo: s
representa un número menor que Single.MinValue o mayor que Single.MaxValue.
Ejemplos
En el ejemplo siguiente se usa el Parse(String, NumberStyles) método para analizar las representaciones de cadena de Single los valores. En el ejemplo se usa información de formato para la referencia cultural en-US.
using System;
using System.Globalization;
using System.Threading;
public class ParseString
{
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)
{
Single number;
try
{
number = Single.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 (styles: NumberStyles) =
try
let number = Single.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.
Imports System.Globalization
Imports System.Threading
Module ParseStrings
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 Single
Try
number = Single.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
End Module
' The example displays the following output to the console:
' Unable to parse '-1.063E-02' with styles AllowExponent.
'
' Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
'
' Converted ' $ 6,164.3299 ' using Number, AllowCurrencySymbol to 6164.3299.
'
' Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
'
' Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.
Comentarios
En .NET Core 3.0 y versiones posteriores, los valores que son demasiado grandes para representar se redondean a PositiveInfinity o NegativeInfinity según lo requiera la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.
El style
parámetro define los elementos de estilo (como espacios en blanco, separadores de miles y símbolos de moneda) que se permiten en el s
parámetro para que la operación de análisis se realice correctamente. Debe ser una combinación de marcas de bits de la NumberStyles enumeración. No se admiten los siguientes NumberStyles miembros:
El s
parámetro puede contener la referencia PositiveInfinitySymbolcultural actual , NegativeInfinitySymbol, NaNSymbol. Dependiendo del valor de style
, también puede tomar la forma:
[ws] [$][sign][integral-digits[,]]integral-digits[.[fracciones de dígitos]] [E[sign]exponencial-digits] [ws]
Los elementos de los corchetes ([ y ]) son opcionales. En esta tabla se describe cada elemento.
Ws Una serie de caracteres de espacio en blanco. El espacio en blanco puede aparecer al principio de s
si incluye la NumberStyles.AllowLeadingWhite marca y puede aparecer al final de s
si style
incluye la NumberStyles.AllowTrailingWhitestyle
marca.
$ Un símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las NumberFormatInfo.CurrencyNegativePattern propiedades y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural actual. El símbolo de moneda de la referencia cultural actual puede aparecer en s
si style
incluye la NumberStyles.AllowCurrencySymbol marca .
Firmar Un símbolo de signo negativo (-) o un símbolo de signo positivo (+). El signo puede aparecer al principio de s
si incluye la NumberStyles.AllowLeadingSign marca y puede aparecer al final de s
si style
incluye la NumberStyles.AllowTrailingSignstyle
marca. Los paréntesis se pueden usar en s
para indicar un valor negativo si style
incluye la NumberStyles.AllowParentheses marca .
dígitos enteros Serie de dígitos comprendidos entre 0 y 9 que especifican la parte integral del número. El elemento integral-digits puede estar ausente si la cadena contiene el elemento fracciones de dígitos .
, separador de grupo específico de la referencia cultural. El símbolo separador de grupo de la referencia cultural actual puede aparecer en s
si style
incluye la NumberStyles.AllowThousands marca .
.
Símbolo de separador decimal específico de la referencia cultural. El símbolo de separador decimal de la referencia cultural actual puede aparecer en s
si style
incluye la NumberStyles.AllowDecimalPoint marca .
fracciones de dígitos Serie de dígitos comprendidos entre 0 y 9 que especifican la parte fraccionarcional del número. Los dígitos fraccionarios pueden aparecer en s
si style
incluye la NumberStyles.AllowDecimalPoint marca .
E El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El value
parámetro puede representar un número en notación exponencial si style
incluye la NumberStyles.AllowExponent marca .
dígitos exponenciales Serie de dígitos comprendidos entre 0 y 9 que especifican un exponente.
Nota
La operación de análisis omite todos los caracteres NUL (U+0000) de s
, independientemente del valor del style
argumento.
Una cadena solo con dígitos (que corresponde al NumberStyles.None estilo) siempre analiza correctamente si está en el intervalo del Single tipo. Los miembros restantes System.Globalization.NumberStyles controlan los elementos que pueden estar presentes, pero no son necesarios para estar presentes, en la cadena de entrada. En la tabla siguiente se indica cómo afectan las marcas individuales NumberStyles a los elementos que pueden estar presentes en s
.
Valor NumberStyles | Elementos permitidos además s de dígitos |
---|---|
None | Solo el elemento integral-digits . |
AllowDecimalPoint | Elementos decimales (.) y fracciones de dígitos . |
AllowExponent | El carácter "e" o "E", que indica la notación exponencial. Esta marca por sí misma admite valores en los dígitosde formaE digits; se necesitan marcas adicionales para analizar correctamente cadenas con elementos como signos positivos o negativos y símbolos decimales. |
AllowLeadingWhite | Elemento ws al principio de s . |
AllowTrailingWhite | Elemento ws al final de s . |
AllowLeadingSign | Elemento sign al principio de s . |
AllowTrailingSign | Elemento sign al final de s . |
AllowParentheses | Elemento de signo en forma de paréntesis que incluye el valor numérico. |
AllowThousands | Elemento separador de miles (,). |
AllowCurrencySymbol | Elemento currency ($). |
Currency | Todos los elementos. Sin embargo, s no puede representar un número hexadecimal o un número en notación exponencial. |
Float | Elemento ws al principio o al final de s , signo al principio de s y el símbolo decimal (.). El s parámetro también puede usar la notación exponencial. |
Number | Los ws elementos separador , sign , miles (,) y decimal point (.). |
Any | Todos los elementos. Sin embargo, s no puede representar un número hexadecimal. |
Algunos ejemplos de s
son "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" y "-Infinity".
El s
parámetro se analiza mediante la información de formato de un NumberFormatInfo objeto que se inicializa para la referencia cultural del sistema actual. Para especificar la referencia cultural cuya información de formato se usa para la operación de análisis, llame a la Parse(String, NumberStyles, IFormatProvider) sobrecarga.
Normalmente, si pasa el Parse método una cadena que se crea mediante una llamada al ToString método , se devuelve el valor original Single . Sin embargo, debido a una pérdida de precisión, los valores pueden no ser iguales.
Si s
está fuera del intervalo del tipo de Single datos, el método produce una OverflowException excepción en .NET Framework y .NET Core 2.2 y versiones anteriores. En .NET Core 3.0 y versiones posteriores, devuelve Single.NegativeInfinity si s
es menor que Single.MinValue y Single.PositiveInfinity si s
es mayor que Single.MaxValue.
Si se encuentra un separador en el s
parámetro durante una operación de análisis y los separadores decimales y de grupo aplicables son iguales, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.
Consulte también
Se aplica a
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