Single.Parse Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Convierte la representación de cadena de un número en su número de punto flotante de precisión sencilla equivalente.

Sobrecargas

Parse(String)	Convierte la representación de cadena de un número en su número de punto flotante de precisión sencilla equivalente.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analiza un intervalo de caracteres UTF-8 en un valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
Parse(String, NumberStyles)	Convierte la representación de cadena de un número en un estilo especificado en su número de punto flotante de precisión sencilla equivalente.
Parse(String, IFormatProvider)	Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado en su 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(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convierte un intervalo de caracteres que contiene la representación de cadena de un número en un estilo especificado y un formato específico de la referencia cultural a su número de punto flotante de precisión sencilla equivalente.
Parse(String, NumberStyles, IFormatProvider)	Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su número de punto flotante de precisión 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 sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

Parse(String)

Source:

Single.cs

Convierte la representación de cadena de un número en su 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

Single

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

Excepciones

ArgumentNullException

s es null.

FormatException

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

OverflowException

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que single.MinValue o superior a Single.MaxValue.

Ejemplos

En el ejemplo siguiente se usa el método Parse(String) para convertir una matriz de cadenas en valores de Single equivalentes.

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 sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

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

[ws] [signo] [enteros [,]]dígitos enteros[.[fracciones]][e[signo]dígitos exponenciales][ws]

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

Elemento	Descripción
ws	Una serie de caracteres de espacio en blanco.
de signo	Símbolo de signo negativo o símbolo de signo positivo. Los caracteres de signo válidos se determinan mediante las propiedades NumberFormatInfo.NegativeSign y NumberFormatInfo.PositiveSign de la referencia cultural actual. Solo se puede usar un signo inicial.
de dígitos enteros	Serie de dígitos que van de 0 a 9 que especifican la parte integral del número. Las ejecuciones de dígitos enteros se pueden particionar mediante un símbolo separador de grupo. Por ejemplo, en algunas referencias culturales, una coma (,) separa grupos de miles. El elemento dígitos enteros puede estar ausente si la cadena contiene los dígitos fraccionarios elemento.
,	Símbolo separador de miles específico de la referencia cultural.
.	Símbolo de separador decimal específico de la referencia cultural.
fracciones de dígitos	Serie de dígitos que van de 0 a 9 que especifican la parte fraccionaria del número.
E	Carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica).
de dígitos exponenciales	Serie de dígitos que van de 0 a 9 que especifican un exponente.

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

El parámetro s se analiza mediante la información de formato de un objeto NumberFormatInfo que se inicializa para la referencia cultural del sistema actual. Para obtener más información, consulte CurrentInfo. Para analizar una cadena mediante la información de formato de una referencia cultural específica, use el método Parse(String, IFormatProvider) o Parse(String, NumberStyles, IFormatProvider).

Normalmente, si pasa el método Parse una cadena que se crea llamando al método ToString, se devuelve el valor de Single original. 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 datos Single, el método inicia una 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 parámetro s durante una operación de análisis y los separadores decimales y de grupo aplicables son los mismos, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.

Consulte también

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

Parse(ReadOnlySpan<Byte>, IFormatProvider)

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

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

Devoluciones

Single

Resultado del análisis utf8Text.

Implementaciones

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(ReadOnlySpan<Char>, IFormatProvider)

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 va a analizar.

provider

IFormatProvider

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

Devoluciones

Single

Resultado del análisis s.

Implementaciones

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(String, NumberStyles)

Source:

Single.cs

Convierte la representación de cadena de un número en un estilo especificado en su número de punto flotante de precisión 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 valores de enumeración que indica los elementos de estilo que pueden estar presentes en s. Un valor típico que se debe especificar se Float combinado con AllowThousands.

Devoluciones

Single

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

Excepciones

ArgumentNullException

s es null.

FormatException

s no es un número en un formato válido.

OverflowException

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que single.MinValue o superior a Single.MaxValue.

ArgumentException

style no es un valor NumberStyles.

-o-

style incluye el valor de AllowHexSpecifier.

Ejemplos

En el ejemplo siguiente se usa el método Parse(String, NumberStyles) para analizar las representaciones de cadena de Single valores. En el ejemplo se usa información de formato para la referencia cultural de 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 sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

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

• AllowHexSpecifier

• HexNumber

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

[ws] [] [signo] [enteros[,]]dígitos enteros[.[fracciones de dígitos]][E[signo]dígitos exponenciales][ws]

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

ws una serie de caracteres de espacio en blanco. El espacio en blanco puede aparecer al principio de s si style incluye la marca NumberStyles.AllowLeadingWhite y puede aparecer al final de s si style incluye la marca NumberStyles.AllowTrailingWhite.

$ Símbolo de moneda específico de la referencia cultural. Su posición en la cadena se define mediante las propiedades NumberFormatInfo.CurrencyNegativePattern y NumberFormatInfo.CurrencyPositivePattern de la referencia cultural actual. El símbolo de moneda de la referencia cultural actual puede aparecer en s si style incluye la marca NumberStyles.AllowCurrencySymbol.

signo un símbolo de signo negativo (-) o un símbolo de signo positivo (+). El signo puede aparecer al principio de s si style incluye la marca NumberStyles.AllowLeadingSign y puede aparecer al final de s si style incluye la marca NumberStyles.AllowTrailingSign. Los paréntesis se pueden usar en s para indicar un valor negativo si style incluye la marca NumberStyles.AllowParentheses.

dígitos enteros una serie de dígitos que van de 0 a 9 que especifican la parte integral del número. El elemento dígitos enteros puede estar ausente si la cadena contiene los dígitos fraccionarios elemento.

, un separador de grupo específico de la referencia cultural. El símbolo separador de grupo de la referencia cultural actual puede aparecer en s si style incluye la marca de NumberStyles.AllowThousands

. Símbolo de separador decimal específico de la referencia cultural. El símbolo de separador decimal de la referencia cultural actual puede aparecer en s si style incluye la marca NumberStyles.AllowDecimalPoint.

fracciones de dígitos una serie de dígitos que van de 0 a 9 que especifican la parte fraccionaria del número. Los dígitos fraccionarios pueden aparecer en s si style incluye la marca NumberStyles.AllowDecimalPoint.

E El carácter "e" o "E", que indica que el valor se representa en notación exponencial (científica). El parámetro value puede representar un número en notación exponencial si style incluye la marca NumberStyles.AllowExponent.

dígitos exponenciales una serie de dígitos que van de 0 a 9 que especifican un exponente.

Nota

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

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

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

Algunos ejemplos de s son "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" y "-Infinity".

El parámetro s se analiza mediante la información de formato de un objeto NumberFormatInfo que se inicializa para la referencia cultural del sistema actual. Para especificar la referencia cultural cuya información de formato se usa para la operación de análisis, llame a la sobrecarga de Parse(String, NumberStyles, IFormatProvider).

Normalmente, si pasa el método Parse una cadena que se crea llamando al método ToString, se devuelve el valor de Single original. 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 datos Single, el método inicia una 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 parámetro s durante una operación de análisis y los separadores decimales y de grupo aplicables son los mismos, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.

Consulte también

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

Parse(String, IFormatProvider)

Source:

Single.cs

Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado en su número de punto flotante de precisión sencilla equivalente.

public:
 static float Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<float>::Parse;

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 sobre s.

Devoluciones

Single

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

Implementaciones

Parse(String, IFormatProvider)

Excepciones

ArgumentNullException

s es null.

FormatException

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

OverflowException

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que single.MinValue o superior a Single.MaxValue.

Ejemplos

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

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 sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

Esta sobrecarga se usa normalmente para convertir texto que se puede dar formato de varias maneras a un valor de Single. Por ejemplo, se puede usar para convertir el texto escrito por un usuario en un cuadro de texto HTML a un valor numérico.

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

[ws] [signo]de dígitos enteros [.[fracciones de dígitos]][E[signo]dígitos exponenciales][ws]

Los elementos opcionales se enmarcan entre corchetes ([ y ]). Los elementos que contienen el término "dígitos" constan de una serie de caracteres numéricos que van de 0 a 9.

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

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

El parámetro provider es una implementación de IFormatProvider cuyo método GetFormat devuelve un objeto NumberFormatInfo que proporciona información de formato específica de la referencia cultural. Cuando se invoca el método Parse(String, IFormatProvider), llama al método GetFormat del parámetro provider y lo pasa un objeto Type que representa el tipo NumberFormatInfo. A continuación, el método GetFormat devuelve el objeto NumberFormatInfo que proporciona información sobre el formato del parámetro s. Hay tres maneras de usar el parámetro provider para proporcionar información de formato personalizada a la operación de análisis:

• Puede pasar un objeto CultureInfo que represente la referencia cultural que proporciona información de formato. Su método GetFormat devuelve el objeto NumberFormatInfo que proporciona información de formato numérico para esa referencia cultural.

• Puede pasar el objeto NumberFormatInfo real que proporciona información de formato numérico. (Su implementación de GetFormat simplemente se devuelve a sí misma).

• Puede pasar un objeto personalizado que implemente IFormatProvider. Su método GetFormat crea instancias y devuelve el objeto NumberFormatInfo que proporciona información de formato.

Si provider es null o no se puede obtener un NumberFormatInfo, se usa la información de formato de la referencia cultural del sistema actual.

Si s está fuera del intervalo del tipo de datos Single, el método inicia una 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 parámetro s durante una operación de análisis y los separadores decimales y de grupo aplicables son los mismos, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.

Algunos ejemplos de s son "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" y "-Infinity".

Consulte también

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

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

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

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

Devoluciones

Single

Resultado del análisis utf8Text.

Implementaciones

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:

Single.cs

Convierte un intervalo de caracteres que contiene la representación de cadena de un número en un estilo especificado y un formato específico de la referencia cultural a su número de punto flotante de precisión sencilla equivalente.

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>

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

style

NumberStyles

Combinación bit a bit de valores de enumeración que indican los elementos de estilo que pueden estar presentes en s. Un valor típico que se debe especificar se Float combinado con AllowThousands.

provider

IFormatProvider

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

Devoluciones

Single

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

Implementaciones

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Excepciones

FormatException

s no representa un valor numérico.

ArgumentException

style no es un valor NumberStyles.

-o-

style es el valor de AllowHexSpecifier.

Comentarios

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

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

Parse(String, NumberStyles, IFormatProvider)

Source:

Single.cs

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

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);

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 valores de enumeración que indica los elementos de estilo que pueden estar presentes en s. Un valor típico que se debe especificar se Float combinado con AllowThousands.

provider

IFormatProvider

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

Devoluciones

Single

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

Implementaciones

Parse(String, NumberStyles, IFormatProvider)

Excepciones

ArgumentNullException

s es null.

FormatException

s no representa un valor numérico.

ArgumentException

style no es un valor NumberStyles.

-o-

style es el valor de AllowHexSpecifier.

OverflowException

.NET Framework y .NET Core 2.2 y versiones anteriores solo: s representa un número menor que single.MinValue o superior a Single.MaxValue.

Ejemplos

En el ejemplo de código siguiente se usa el método Parse(String, NumberStyles, IFormatProvider) para analizar las representaciones de cadena de Single valores. Cada cadena de una matriz se analiza mediante las convenciones de formato de la en-US, nl-NLy una referencia cultural personalizada. La referencia cultural personalizada define su símbolo separador de grupo como 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 sea necesario en la especificación IEEE 754. En versiones anteriores, incluido .NET Framework, el análisis de un valor demasiado grande para representar se produjo un error.

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

• AllowHexSpecifier

• HexNumber

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

[ws] [] [signo] [enteros ,][.[fracciones de dígitos]][E[signo]dígitos exponenciales][ws]

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

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

Nota

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

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

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

El parámetro provider es una implementación de IFormatProvider. Su método GetFormat devuelve un objeto NumberFormatInfo 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 método GetFormat devuelve el objeto NumberFormatInfo que proporciona información de formato numérico.

• Objeto NumberFormatInfo que proporciona información de formato. (Su implementación de GetFormat simplemente se devuelve a sí misma).

• Objeto personalizado que implementa IFormatProvider y usa el método GetFormat para crear instancias y devolver el objeto NumberFormatInfo que proporciona información de formato.

Si provider es null, se usa el objeto NumberFormatInfo para la referencia cultural actual.

Si s está fuera del intervalo del tipo de datos Single, el método inicia una 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 parámetro s durante una operación de análisis y los separadores decimales y de grupo aplicables son los mismos, la operación de análisis supone que el separador es un separador decimal en lugar de un separador de grupo. Para obtener más información sobre los separadores, vea CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatory NumberGroupSeparator.

Consulte también

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