Single.Parse Metodo

Origine:

Single.cs

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo specificato in s.

Eccezioni

Esempio

Nell'esempio seguente viene utilizzato il metodo Parse(String) per convertire una matrice di stringhe in valori Single equivalenti.

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.

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

Il parametro s può contenere il PositiveInfinitySymboldelle impostazioni cultura correnti, NegativeInfinitySymbol, NaNSymbolo una stringa del formato:

[ws] [firma] [cifre integrali[,]]cifre integrali[.[frazionarie]][e[segno]cifre esponenziali][ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive ogni elemento.

Il parametro s viene interpretato usando una combinazione di flag NumberStyles.Float e NumberStyles.AllowThousands. Ciò significa che gli spazi vuoti e le migliaia di separatori sono consentiti, ma i simboli di valuta non sono. Per definire in modo esplicito gli elementi ,ad esempio simboli di valuta, migliaia di separatori e spazi vuoti, che possono essere presenti in s, usare l'overload del metodo Parse(String, NumberStyles).

Il parametro s viene analizzato usando le informazioni di formattazione in un oggetto NumberFormatInfo inizializzato per le impostazioni cultura di sistema correnti. Per altre informazioni, vedere CurrentInfo. Per analizzare una stringa usando le informazioni di formattazione di impostazioni cultura specifiche, utilizzare il metodo Parse(String, IFormatProvider) o Parse(String, NumberStyles, IFormatProvider).

In genere, se si passa il metodo Parse una stringa creata chiamando il metodo ToString, viene restituito il valore Single originale. Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali.

Se s non è compreso nell'intervallo del tipo di dati Single, il metodo genera un OverflowException in .NET Framework e .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive restituisce Single.NegativeInfinity se s è minore di Single.MinValue e Single.PositiveInfinity se s è maggiore di Single.MaxValue.

Se viene rilevato un separatore nel parametro s durante un'operazione di analisi e i separatori decimali o numerici applicabili sono gli stessi, l'operazione di analisi presuppone che il separatore sia un separatore decimale anziché un separatore di gruppo. Per altre informazioni sui separatori, vedere CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Vedi anche

• ToString()
• l'analisi di stringhe numeriche in .NET

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Risultato dell'analisi utf8Text.

Implementazioni

Origine:

Single.cs

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Risultato dell'analisi s.

Implementazioni

Origine:

Single.cs

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Numero a virgola mobile e precisione singola equivalente al valore numerico o al simbolo specificato in s.

Eccezioni

Esempio

Nell'esempio seguente viene utilizzato il metodo Parse(String, NumberStyles) per analizzare le rappresentazioni di stringa dei valori Single. Nell'esempio vengono utilizzate informazioni di formattazione per le impostazioni cultura 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.

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

Il parametro style definisce gli elementi di stile,ad esempio spazi vuoti, migliaia di separatori e simboli di valuta, consentiti nel parametro s per l'esito positivo dell'operazione di analisi. Deve essere una combinazione di flag di bit dell'enumerazione NumberStyles. I membri NumberStyles seguenti non sono supportati:

• AllowHexSpecifier

• HexNumber

Il parametro s può contenere le impostazioni cultura correnti PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbol. A seconda del valore di style, può anche assumere il formato :

[ws] [$] [firma] [cifre integrali[,]]cifre integrali[.[frazionarie]][E[segno]cifre esponenziali][ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive ogni elemento.

ws Serie di spazi vuoti. Gli spazi vuoti possono essere visualizzati all'inizio di s se style include il flag di NumberStyles.AllowLeadingWhite e possono essere visualizzati alla fine di s se style include il flag NumberStyles.AllowTrailingWhite.

$ Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla NumberFormatInfo.CurrencyNegativePattern e dalle proprietà NumberFormatInfo.CurrencyPositivePattern delle impostazioni cultura correnti. Il simbolo di valuta delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowCurrencySymbol.

segno Simbolo di segno negativo (-) o simbolo di segno positivo (+). Il segno può essere visualizzato all'inizio di s se style include il flag di NumberStyles.AllowLeadingSign e può essere visualizzato alla fine di s se style include il flag NumberStyles.AllowTrailingSign. Le parentesi possono essere usate in s per indicare un valore negativo se style include il flag NumberStyles.AllowParentheses.

cifre integrali Serie di cifre comprese tra 0 e 9 che specificano la parte integrante del numero. L'elemento cifre integrali può essere assente se la stringa contiene l'elemento cifre frazionarie elemento .

, separatore di gruppo specifico delle impostazioni cultura. Il simbolo separatore di gruppo delle impostazioni cultura corrente può essere visualizzato in s se style include il flag di NumberStyles.AllowThousands

. Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo decimale delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowDecimalPoint.

frazionarie Serie di cifre comprese tra 0 e 9 che specificano la parte frazionaria del numero. Le cifre frazionarie possono essere visualizzate in s se style include il flag di NumberStyles.AllowDecimalPoint.

E Il carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il parametro value può rappresentare un numero in notazione esponenziale se style include il flag NumberStyles.AllowExponent.

cifre esponenziali serie di cifre comprese tra 0 e 9 che specificano un esponente.

Una stringa con solo cifre (che corrisponde allo stile NumberStyles.None) analizza sempre correttamente se si trova nell'intervallo del tipo Single. Gli altri System.Globalization.NumberStyles membri controllano elementi che possono essere presenti, ma non devono essere presenti, nella stringa di input. La tabella seguente indica in che modo i singoli flag di NumberStyles influiscono sugli elementi che possono essere presenti in s.

Alcuni esempi di s sono "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" e "-Infinity".

Il parametro s viene analizzato usando le informazioni di formattazione in un oggetto NumberFormatInfo inizializzato per le impostazioni cultura di sistema correnti. Per specificare le impostazioni cultura le cui informazioni di formattazione vengono utilizzate per l'operazione di analisi, chiamare l'overload Parse(String, NumberStyles, IFormatProvider).

In genere, se si passa il metodo Parse una stringa creata chiamando il metodo ToString, viene restituito il valore Single originale. Tuttavia, a causa di una perdita di precisione, i valori potrebbero non essere uguali.

Se s non è compreso nell'intervallo del tipo di dati Single, il metodo genera un OverflowException in .NET Framework e .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive restituisce Single.NegativeInfinity se s è minore di Single.MinValue e Single.PositiveInfinity se s è maggiore di Single.MaxValue.

Se viene rilevato un separatore nel parametro s durante un'operazione di analisi e i separatori decimali o numerici applicabili sono gli stessi, l'operazione di analisi presuppone che il separatore sia un separatore decimale anziché un separatore di gruppo. Per altre informazioni sui separatori, vedere CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Vedi anche

• ToString()
• TryParse
• l'analisi di stringhe numeriche in .NET

Origine:

Single.cs

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo specificato in s.

Implementazioni

Eccezioni

Esempio

L'esempio seguente è il gestore eventi click del pulsante di un modulo Web. Usa la matrice restituita dalla proprietà HttpRequest.UserLanguages per determinare le impostazioni locali dell'utente. Crea quindi un'istanza di un oggetto CultureInfo che corrisponde a tale impostazione locale. L'oggetto NumberFormatInfo appartenente a tale oggetto CultureInfo viene quindi passato al metodo Parse(String, IFormatProvider) per convertire l'input dell'utente in un valore 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

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

Questo overload viene in genere usato per convertire il testo che può essere formattato in diversi modi in un valore Single. Ad esempio, può essere usato per convertire il testo immesso da un utente in una casella di testo HTML in un valore numerico.

Il parametro s viene interpretato usando una combinazione di flag NumberStyles.Float e NumberStyles.AllowThousands. Il parametro s può contenere NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol per le impostazioni cultura specificate da provideroppure può contenere una stringa del form:

[ws] [segno]cifre integrali[.[cifre frazionarie]][E[ segno]cifre esponenziali][ws]

Gli elementi facoltativi sono racchiusi tra parentesi quadre ([ e ]). Gli elementi che contengono il termine "cifre" sono costituiti da una serie di caratteri numerici compresi tra 0 e 9.

Per altre informazioni sui formati numerici, vedere l'argomento Formattazione dei tipi.

Il parametro provider è un'implementazione IFormatProvider il cui metodo GetFormat restituisce un oggetto NumberFormatInfo che fornisce informazioni di formattazione specifiche delle impostazioni cultura. Quando viene richiamato il metodo Parse(String, IFormatProvider), chiama il metodo GetFormat del parametro provider e lo passa a un oggetto Type che rappresenta il tipo di NumberFormatInfo. Il metodo GetFormat restituisce quindi l'oggetto NumberFormatInfo che fornisce informazioni sul formato del parametro s. Esistono tre modi per usare il parametro provider per fornire informazioni di formattazione personalizzate all'operazione di analisi:

• È possibile passare un oggetto CultureInfo che rappresenta le impostazioni cultura che forniscono informazioni di formattazione. Il metodo GetFormat restituisce l'oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica per tali impostazioni cultura.

• È possibile passare l'oggetto NumberFormatInfo effettivo che fornisce informazioni sulla formattazione numerica. L'implementazione di GetFormat restituisce solo se stessa.

• È possibile passare un oggetto personalizzato che implementa IFormatProvider. Il metodo GetFormat crea un'istanza e restituisce l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null o non è possibile ottenere un NumberFormatInfo, vengono utilizzate le informazioni di formattazione per le impostazioni cultura di sistema correnti.

Se s non è compreso nell'intervallo del tipo di dati Single, il metodo genera un OverflowException in .NET Framework e .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive restituisce Single.NegativeInfinity se s è minore di Single.MinValue e Single.PositiveInfinity se s è maggiore di Single.MaxValue.

Se viene rilevato un separatore nel parametro s durante un'operazione di analisi e i separatori decimali o numerici applicabili sono gli stessi, l'operazione di analisi presuppone che il separatore sia un separatore decimale anziché un separatore di gruppo. Per altre informazioni sui separatori, vedere CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Alcuni esempi di s sono "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" e "-Infinity".

Vedi anche

• ToString()
• TryParse
• l'analisi di stringhe numeriche in .NET

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Risultato dell'analisi utf8Text.

Implementazioni

Origine:

Single.cs

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Numero a virgola mobile e precisione singola equivalente al valore numerico o al simbolo specificato in s.

Implementazioni

Eccezioni

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

Se s non è compreso nell'intervallo del tipo di dati Single, il metodo restituisce Single.NegativeInfinity se s è minore di Single.MinValue e Single.PositiveInfinity se s è maggiore di Single.MaxValue.

Origine:

Single.cs

Origine:

Single.cs

Origine:

Single.cs

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

Parametri

Restituisce

Numero a virgola mobile a precisione singola equivalente al valore numerico o al simbolo specificato in s.

Implementazioni

Eccezioni

Esempio

Nell'esempio di codice seguente viene usato il metodo Parse(String, NumberStyles, IFormatProvider) per analizzare le rappresentazioni di stringa dei valori Single. Ogni stringa in una matrice viene analizzata usando le convenzioni di formattazione del en-US, nl-NLe impostazioni cultura personalizzate. Le impostazioni cultura personalizzate definiscono il simbolo separatore di gruppo come carattere di sottolineatura ("_") e le relative dimensioni del gruppo come due.

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.

Commenti

In .NET Core 3.0 e versioni successive, i valori troppo grandi da rappresentare vengono arrotondati a PositiveInfinity o NegativeInfinity come richiesto dalla specifica IEEE 754. Nelle versioni precedenti, incluso .NET Framework, l'analisi di un valore troppo grande per rappresentare il risultato di un errore.

Il parametro style definisce gli elementi di stile,ad esempio spazi vuoti, migliaia di separatori e simboli di valuta, consentiti nel parametro s per l'esito positivo dell'operazione di analisi. Deve essere una combinazione di flag di bit dell'enumerazione NumberStyles. I membri NumberStyles seguenti non sono supportati:

• AllowHexSpecifier

• HexNumber

Il parametro s può contenere NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolo NumberFormatInfo.NaNSymbol per le impostazioni cultura specificate da provider. A seconda del valore di style, può anche assumere il formato :

[ws] [] [firma] [cifre integrali,]cifre integrali[.[cifre frazionarie]][E[ segno]cifre esponenziali][ws]

Gli elementi racchiusi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive ogni elemento.

Una stringa con solo cifre (che corrisponde allo stile NumberStyles.None) analizza sempre correttamente se si trova nell'intervallo del tipo Single. Gli altri System.Globalization.NumberStyles membri controllano elementi che possono essere presenti, ma non devono essere presenti, nella stringa di input. La tabella seguente indica in che modo i singoli flag di NumberStyles influiscono sugli elementi che possono essere presenti in s.

Il parametro provider è un'implementazione IFormatProvider. Il metodo GetFormat restituisce un oggetto NumberFormatInfo che fornisce informazioni specifiche delle impostazioni cultura sul formato di value. In genere, provider può essere uno dei seguenti:

• Oggetto CultureInfo che rappresenta le impostazioni cultura che forniscono informazioni sulla formattazione numerica. Il metodo GetFormat restituisce l'oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica.

• Oggetto NumberFormatInfo che fornisce informazioni di formattazione. L'implementazione di GetFormat restituisce solo se stessa.

• Oggetto personalizzato che implementa IFormatProvider e usa il metodo GetFormat per creare un'istanza e restituire l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene utilizzato l'oggetto NumberFormatInfo per le impostazioni cultura correnti.

Se s non è compreso nell'intervallo del tipo di dati Single, il metodo genera un OverflowException in .NET Framework e .NET Core 2.2 e versioni precedenti. In .NET Core 3.0 e versioni successive restituisce Single.NegativeInfinity se s è minore di Single.MinValue e Single.PositiveInfinity se s è maggiore di Single.MaxValue.

Se viene rilevato un separatore nel parametro s durante un'operazione di analisi e i separatori decimali o numerici applicabili sono gli stessi, l'operazione di analisi presuppone che il separatore sia un separatore decimale anziché un separatore di gruppo. Per altre informazioni sui separatori, vedere CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatore NumberGroupSeparator.

Vedi anche

• ToString()
• l'analisi di stringhe numeriche in .NET