Single.Parse Methode

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Een drijvendekommagetal met één precisie dat gelijk is aan de numerieke waarde of het symbool dat is opgegeven in s.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt de Parse(String) methode gebruikt om een matrix met tekenreeksen te converteren naar equivalente Single waarden.

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.

Opmerkingen

In .NET Core 3.0 en hoger worden waarden die te groot zijn om weer te geven afgerond op PositiveInfinity of NegativeInfinity zoals vereist door de IEEE 754-specificatie. In eerdere versies, met inbegrip van .NET Framework, parseert u een waarde die te groot was om aan te geven dat dit resulteert in een fout.

De s parameter kan de huidige cultuur PositiveInfinitySymbolof NegativeInfinitySymbolNaNSymbol het symbool bevatten. Deze tekenreeksvergelijking is niet hoofdlettergevoelig in .NET Core 3.0 en latere versies, maar is hoofdlettergevoelig in eerdere versies, waaronder .NET Framework. De s parameter kan ook een tekenreeks van het formulier zijn:

[ws][teken] [integral-digits[,]]integral-digits[.[fractionele cijfers]][e[sign]exponentiële cijfers][ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Een reeks witruimtetekens.
ondertekenen	Een negatief tekensymbool of een positief tekenteken. Geldige tekens worden bepaald door de NumberFormatInfo.NegativeSign en NumberFormatInfo.PositiveSign eigenschappen van de huidige cultuur. Alleen een voorloopteken kan worden gebruikt.
integral-digits	Een reeks cijfers tussen 0 en 9 die het integraal deel van het getal aangeven. Uitvoeringen van integrale cijfers kunnen worden gepartitioneerd door een groepsscheidingsteken. In sommige culturen scheidt een komma (,) bijvoorbeeld groepen van duizenden. Het element integral-digits kan afwezig zijn als de tekenreeks het element fractionele cijfers bevat.
,	Een cultuurspecifiek scheidingsteken voor duizendtallen.
.	Een cultuurspecifiek decimaalteken.
fractionele cijfers	Een reeks cijfers tussen 0 en 9 die het breukgedeelte van het getal aangeven.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie.
exponentiële cijfers	Een reeks cijfers tussen 0 en 9 die een exponent opgeven.

De s parameter wordt geïnterpreteerd met behulp van een combinatie van de NumberStyles.Float en NumberStyles.AllowThousands vlaggen. Dit betekent dat witruimte en scheidingstekens voor duizendtallen zijn toegestaan, maar valutasymbolen niet. Als u de elementen (zoals valutasymbolen, scheidingstekens voor duizendtallen en witruimte) expliciet wilt definiëren, sgebruikt u de overbelasting van de Parse(String, NumberStyles) methode.

De s parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo object dat is geïnitialiseerd voor de huidige systeemcultuur. Zie CurrentInfo voor meer informatie. Als u een tekenreeks wilt parseren met behulp van de opmaakgegevens van een specifieke cultuur, gebruikt u de Parse(String, IFormatProvider) of Parse(String, NumberStyles, IFormatProvider) methode.

Normaal gesproken wordt de oorspronkelijke Parse waarde geretourneerd als u de ToString methode doorgeeft een tekenreeks die wordt gemaakt door de Single methode aan te roepen. Vanwege een verlies van precisie zijn de waarden echter mogelijk niet gelijk.

Als s buiten het bereik van het gegevenstype Single valt, genereert de methode een OverflowException in .NET Framework. In .NET Core 3.0 en latere versies wordt Single.NegativeInfinity geretourneerd als s kleiner is dan Single.MinValue en Single.PositiveInfinity als s groter is dan Single.MaxValue.

Als er tijdens een parseringsbewerking een scheidingsteken wordt aangetroffen in de s parameter en de toepasselijke valuta- of getaldecimaaltekens en groepsscheidingstekens hetzelfde zijn, wordt bij de parseringsbewerking ervan uitgegaan dat het scheidingsteken een decimaalteken is in plaats van een scheidingsteken voor groepen. Zie , CurrencyDecimalSeparator, en NumberDecimalSeparatorCurrencyGroupSeparatorvoor meer informatie over scheidingstekens NumberGroupSeparator.

Zie ook

• ToString()
• Parsing Numerieke tekenreeksen in .NET

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Het resultaat van parseren utf8Text.

Implementeringen

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Het resultaat van parseren s.

Implementeringen

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Een drijvendekommagetal met één precisie dat gelijk is aan de numerieke waarde of het symbool dat is opgegeven in s.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt de Parse(String, NumberStyles) methode gebruikt om de tekenreeksweergaven van Single waarden te parseren. In het voorbeeld wordt opmaakgegevens gebruikt voor de en-US cultuur.

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.

Opmerkingen

In .NET Core 3.0 en hoger worden waarden die te groot zijn om weer te geven afgerond op PositiveInfinity of NegativeInfinity zoals vereist door de IEEE 754-specificatie. In eerdere versies, met inbegrip van .NET Framework, parseert u een waarde die te groot was om aan te geven dat dit resulteert in een fout.

De style parameter definieert de stijlelementen (zoals witruimte, scheidingstekens voor duizendtallen en valutasymbolen) die zijn toegestaan in de s parameter om de parseringsbewerking te laten slagen. Dit moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming. De volgende NumberStyles leden worden niet ondersteund:

• AllowHexSpecifier

• HexNumber

De s parameter kan de huidige cultuur PositiveInfinitySymbolof NegativeInfinitySymbolNaNSymbol het symbool bevatten. Deze tekenreeksvergelijking is niet hoofdlettergevoelig in .NET Core 3.0 en latere versies, maar is hoofdlettergevoelig in eerdere versies, waaronder .NET Framework. Afhankelijk van de waarde van style, kan de s parameter ook de volgende vorm aannemen:

[ws][$][sign][integral-digits[,]]integral-digits[.[fractionele cijfers]][E[sign]exponentiële cijfers][ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Ws Een reeks witruimtetekens. Witruimte kan aan het begin van s de styleNumberStyles.AllowLeadingWhite vlag worden weergegeven en deze kan aan het einde van s de styleNumberStyles.AllowTrailingWhite vlag worden weergegeven.

$ Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyNegativePattern en NumberFormatInfo.CurrencyPositivePattern eigenschappen van de huidige cultuur. Het valutasymbool van de huidige cultuur kan worden weergegeven als sstyle deze de NumberStyles.AllowCurrencySymbol vlag bevat.

Teken Een symbool voor een negatief teken (-) of een positief teken (+). Het teken kan aan het begin van s de styleNumberStyles.AllowLeadingSign vlag worden weergegeven en kan aan het einde van s de vlag worden weergegeven.styleNumberStyles.AllowTrailingSign Haakjes kunnen worden gebruikt s om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.

integral-digits Een reeks cijfers tussen 0 en 9 die het integraal deel van het getal aangeven. Het element integral-digits kan afwezig zijn als de tekenreeks het element fractionele cijfers bevat.

, een cultuurspecifiek groepsscheidingsteken. Het groepsscheidingsteken van de huidige cultuur kan worden weergegeven als sstyle deze de NumberStyles.AllowThousands vlag bevat

. Een cultuurspecifiek decimaalteken. Het decimale puntsymbool van de huidige cultuur kan worden weergegeven s als style deze de NumberStyles.AllowDecimalPoint vlag bevat.

fractionele cijfers Een reeks cijfers tussen 0 en 9 die het breukgedeelte van het getal aangeven. Fractionele cijfers kunnen worden weergegeven als sstyle deze de NumberStyles.AllowDecimalPoint vlag bevat.

E Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie. De value parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.

exponentiële cijfers Een reeks cijfers tussen 0 en 9 die een exponent opgeven.

Een tekenreeks met alleen cijfers (die overeenkomt met de NumberStyles.None stijl) parseert altijd goed als deze zich in het bereik van het Single type bevindt. De resterende System.Globalization.NumberStyles leden bepalen elementen die mogelijk aanwezig zijn, maar die niet aanwezig zijn, in de invoertekenreeks. De volgende tabel geeft aan hoe afzonderlijke NumberStyles vlaggen van invloed zijn op de elementen die mogelijk aanwezig zijn in s.

NumberStyles-waarde	Elementen die naast cijfers zijn toegestaan s
None	Het element integrale cijfers alleen.
AllowDecimalPoint	De decimale puntelementen (.) en fractionele cijfers .
AllowExponent	Het teken "e" of "E", dat een exponentiële notatie aangeeft. Deze vlag ondersteunt op zichzelf waarden in deformuliercijfers E-cijfers; er zijn extra vlaggen nodig om tekenreeksen te parseren met elementen zoals positieve of negatieve tekens en decimale kommasymbolen.
AllowLeadingWhite	Het ws-element aan het begin van s.
AllowTrailingWhite	Het ws-element aan het einde van s.
AllowLeadingSign	Het tekenelement aan het begin van s.
AllowTrailingSign	Het tekenelement aan het einde van s.
AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
AllowThousands	Het scheidingsteken voor duizendtallen (,)
AllowCurrencySymbol	Het valutaelement ($).
Currency	Alle elementen. s Kan echter geen hexadecimaal getal of een getal in exponentiële notatie vertegenwoordigen.
Float	Het ws-element aan het begin of einde van s, het teken aan het begin van sen het decimaalteken (.). De s parameter kan ook exponentiële notatie gebruiken.
Number	De wselementen , signscheidingsteken voor duizendtallen (,) en decimaalteken (.).
Any	Alle elementen. s Kan echter geen hexadecimaal getal vertegenwoordigen.

Enkele voorbeelden hiervan s zijn '100', '-123,456,789', '123.45e+6', '+500', '5e2', '3.1416', '600', '-.123' en '-Infinity'.

De s parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo object dat is geïnitialiseerd voor de huidige systeemcultuur. Als u de cultuur wilt opgeven waarvan de opmaakgegevens worden gebruikt voor de parseringsbewerking, roept u de Parse(String, NumberStyles, IFormatProvider) overbelasting aan.

Normaal gesproken wordt de oorspronkelijke Parse waarde geretourneerd als u de ToString methode doorgeeft een tekenreeks die wordt gemaakt door de Single methode aan te roepen. Vanwege een verlies van precisie zijn de waarden echter mogelijk niet gelijk.

Als s buiten het bereik van het gegevenstype Single valt, genereert de methode een OverflowException in .NET Framework. In .NET Core 3.0 en latere versies wordt Single.NegativeInfinity geretourneerd als s kleiner is dan Single.MinValue en Single.PositiveInfinity als s groter is dan Single.MaxValue.

Als er tijdens een parseringsbewerking een scheidingsteken wordt aangetroffen in de s parameter en de toepasselijke valuta- of getaldecimaaltekens en groepsscheidingstekens hetzelfde zijn, wordt bij de parseringsbewerking ervan uitgegaan dat het scheidingsteken een decimaalteken is in plaats van een scheidingsteken voor groepen. Zie , CurrencyDecimalSeparator, en NumberDecimalSeparatorCurrencyGroupSeparatorvoor meer informatie over scheidingstekens NumberGroupSeparator.

Zie ook

• ToString()
• TryParse
• Parsing Numerieke tekenreeksen in .NET

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Een drijvendekommagetal met één precisie dat gelijk is aan de numerieke waarde of het symbool dat is opgegeven in s.

Implementeringen

Uitzonderingen

Voorbeelden

Het volgende voorbeeld is de knop klik op gebeurtenishandler van een webformulier. Hierbij wordt de matrix gebruikt die door de HttpRequest.UserLanguages eigenschap wordt geretourneerd om de landinstelling van de gebruiker te bepalen. Vervolgens wordt een CultureInfo object geïnstitueert dat overeenkomt met die landinstelling. Het NumberFormatInfo object dat bij dat CultureInfo object hoort, wordt vervolgens doorgegeven aan de Parse(String, IFormatProvider) methode om de invoer van de gebruiker te converteren naar een Single waarde.

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

Opmerkingen

In .NET Core 3.0 en hoger worden waarden die te groot zijn om weer te geven afgerond op PositiveInfinity of NegativeInfinity zoals vereist door de IEEE 754-specificatie. In eerdere versies, met inbegrip van .NET Framework, parseert u een waarde die te groot was om aan te geven dat dit resulteert in een fout.

Deze overbelasting wordt meestal gebruikt om tekst te converteren die op verschillende manieren kan worden opgemaakt naar een Single waarde. Het kan bijvoorbeeld worden gebruikt om de tekst die door een gebruiker is ingevoerd, te converteren naar een HTML-tekstvak naar een numerieke waarde.

De s parameter wordt geïnterpreteerd met behulp van een combinatie van de NumberStyles.Float en NumberStyles.AllowThousands vlaggen. De s parameter kan NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolof NumberFormatInfo.NaNSymbol symbool voor de cultuur die is opgegeven door provider. Deze tekenreeksvergelijking is niet hoofdlettergevoelig in .NET Core 3.0 en latere versies, maar is hoofdlettergevoelig in eerdere versies, waaronder .NET Framework. De s parameter kan een tekenreeks van het formulier bevatten:

[ws][teken]integral-digits[.[fractionele cijfers]][E[sign]exponentiële cijfers][ws]

Optionele elementen worden omlijst tussen vierkante haken ([ en ]). Elementen die de term 'cijfers' bevatten, bestaan uit een reeks numerieke tekens tussen 0 en 9.

Element	Beschrijving
Ws	Een reeks witruimtetekens.
ondertekenen	Een symbool voor een negatief teken (-) of een positief teken (+).
integral-digits	Een reeks cijfers tussen 0 en 9 die het integraal deel van het getal aangeven. Uitvoeringen van integrale cijfers kunnen worden gepartitioneerd door een groepsscheidingsteken. In sommige culturen scheidt een komma (,) bijvoorbeeld groepen van duizenden. Het element integral-digits kan afwezig zijn als de tekenreeks het element fractionele cijfers bevat.
.	Een cultuurspecifiek decimaalteken.
fractionele cijfers	Een reeks cijfers tussen 0 en 9 die het breukgedeelte van het getal aangeven.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie.
exponentiële cijfers	Een reeks cijfers tussen 0 en 9 die een exponent opgeven.

Zie het onderwerp Opmaaktypen voor meer informatie over numerieke notaties.

De provider parameter is een IFormatProvider implementatie waarvan de GetFormat methode een NumberFormatInfo object retourneert dat cultuurspecifieke opmaakinformatie biedt. Wanneer de Parse(String, IFormatProvider) methode wordt aangeroepen, wordt de methode van provider de GetFormat parameter aangeroepen en doorgegeven aan een Type object dat het NumberFormatInfo type vertegenwoordigt. De GetFormat methode retourneert vervolgens het NumberFormatInfo object dat informatie biedt over de indeling van de s parameter. Er zijn drie manieren om de provider parameter te gebruiken om aangepaste opmaakgegevens op te geven voor de parseringsbewerking:

• U kunt een CultureInfo object doorgeven dat de cultuur vertegenwoordigt die opmaakinformatie levert. De GetFormat methode retourneert het NumberFormatInfo object dat numerieke opmaakinformatie biedt voor die cultuur.

• U kunt het werkelijke NumberFormatInfo object doorgeven dat numerieke opmaakgegevens biedt. (De implementatie van GetFormat alleen retourneert zichzelf.)

• U kunt een aangepast object doorgeven dat wordt geïmplementeerd IFormatProvider. De GetFormat methode instantieert en retourneert het NumberFormatInfo object dat opmaakinformatie biedt.

Als provider dit wel null of niet NumberFormatInfo kan worden verkregen, wordt de opmaakinformatie voor de huidige systeemcultuur gebruikt.

Als s buiten het bereik van het gegevenstype Single valt, genereert de methode een OverflowException in .NET Framework. In .NET Core 3.0 en latere versies wordt Single.NegativeInfinity geretourneerd als s kleiner is dan Single.MinValue en Single.PositiveInfinity als s groter is dan Single.MaxValue.

Als er tijdens een parseringsbewerking een scheidingsteken wordt aangetroffen in de s parameter en de toepasselijke valuta- of getaldecimaaltekens en groepsscheidingstekens hetzelfde zijn, wordt bij de parseringsbewerking ervan uitgegaan dat het scheidingsteken een decimaalteken is in plaats van een scheidingsteken voor groepen. Zie , CurrencyDecimalSeparator, en NumberDecimalSeparatorCurrencyGroupSeparatorvoor meer informatie over scheidingstekens NumberGroupSeparator.

Enkele voorbeelden hiervan s zijn '100', '-123,456,789', '123.45e+6', '+500', '5e2', '3.1416', '600', '-.123' en '-Infinity'.

Zie ook

• ToString()
• TryParse
• Parsing Numerieke tekenreeksen in .NET

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Het resultaat van parseren utf8Text.

Implementeringen

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Een drijvendekommagetal met één precisie dat gelijk is aan de numerieke waarde of het symbool dat is opgegeven in s.

Implementeringen

Uitzonderingen

Opmerkingen

In .NET Core 3.0 en hoger worden waarden die te groot zijn om weer te geven afgerond op PositiveInfinity of NegativeInfinity zoals vereist door de IEEE 754-specificatie. In eerdere versies, met inbegrip van .NET Framework, parseert u een waarde die te groot was om aan te geven dat dit resulteert in een fout.

Als s het gegevenstype buiten het Single bereik valt, retourneert Single.NegativeInfinity de methode of s deze kleiner is dan Single.MinValue en Single.PositiveInfinity groter s is dan Single.MaxValue.

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

Single.cs

Bron:

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

Parameters

Retouren

Een drijvendekommagetal met één precisie dat gelijk is aan de numerieke waarde of het symbool dat is opgegeven in s.

Implementeringen

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld wordt de Parse(String, NumberStyles, IFormatProvider) methode gebruikt om de tekenreeksweergaven van Single waarden te parseren. Elke tekenreeks in een matrix wordt geparseerd met behulp van de opmaakconventies van de en-US, nl-NLen een aangepaste cultuur. De aangepaste cultuur definieert het groepsscheidingsteken als het onderstrepingsteken ("_") en de groepsgrootte als twee.

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.

Opmerkingen

In .NET Core 3.0 en hoger worden waarden die te groot zijn om weer te geven afgerond op PositiveInfinity of NegativeInfinity zoals vereist door de IEEE 754-specificatie. In eerdere versies, met inbegrip van .NET Framework, parseert u een waarde die te groot was om aan te geven dat dit resulteert in een fout.

De style parameter definieert de stijlelementen (zoals witruimte, scheidingstekens voor duizendtallen en valutasymbolen) die zijn toegestaan in de s parameter om de parseringsbewerking te laten slagen. Dit moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming. De volgende NumberStyles leden worden niet ondersteund:

• AllowHexSpecifier

• HexNumber

De s parameter kan NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolof NumberFormatInfo.NaNSymbol symbool voor de cultuur die is opgegeven door provider. Deze tekenreeksvergelijking is niet hoofdlettergevoelig in .NET Core 3.0 en latere versies, maar is hoofdlettergevoelig in eerdere versies, waaronder .NET Framework. Afhankelijk van de waarde van style, kan de s parameter ook de volgende vorm aannemen:

[ws] [$] [sign][integral-digits,]integral-digits[.[fractionele cijfers]][E[sign]exponentiële cijfers][ws]

Elementen die zijn omkaderd in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Een reeks witruimtetekens. Witruimte kan aan het begin van s de styleNumberStyles.AllowLeadingWhite vlag worden weergegeven en deze kan aan het einde van s de styleNumberStyles.AllowTrailingWhite vlag worden weergegeven.
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyNegativePattern en NumberFormatInfo.CurrencyPositivePattern eigenschappen van de huidige cultuur. Het valutasymbool van de huidige cultuur kan worden weergegeven als sstyle deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een symbool voor een negatief teken (-) of een positief teken (+). Het teken kan aan het begin van s de styleNumberStyles.AllowLeadingSign vlag worden weergegeven en kan aan het einde van s de vlag worden weergegeven.styleNumberStyles.AllowTrailingSign Haakjes kunnen worden gebruikt s om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.
integral-digits	Een reeks cijfers tussen 0 en 9 die het integraal deel van het getal aangeven. Het element integral-digits kan afwezig zijn als de tekenreeks het element fractionele cijfers bevat.
,	Een cultuurspecifiek groepsscheidingsteken. Het groepsscheidingsteken van de huidige cultuur kan worden weergegeven als sstyle deze de NumberStyles.AllowThousands vlag bevat
.	Een cultuurspecifiek decimaalteken. Het decimale puntsymbool van de huidige cultuur kan worden weergegeven s als style deze de NumberStyles.AllowDecimalPoint vlag bevat.
fractionele cijfers	Een reeks cijfers tussen 0 en 9 die het breukgedeelte van het getal aangeven. Fractionele cijfers kunnen worden weergegeven als sstyle deze de NumberStyles.AllowDecimalPoint vlag bevat.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie. De s parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
exponentiële cijfers	Een reeks cijfers tussen 0 en 9 die een exponent opgeven.

Een tekenreeks met alleen cijfers (die overeenkomt met de NumberStyles.None stijl) parseert altijd goed als deze zich in het bereik van het Single type bevindt. De resterende System.Globalization.NumberStyles leden bepalen elementen die mogelijk aanwezig zijn, maar die niet aanwezig zijn, in de invoertekenreeks. De volgende tabel geeft aan hoe afzonderlijke NumberStyles vlaggen van invloed zijn op de elementen die mogelijk aanwezig zijn in s.

NumberStyles-waarde	Elementen die naast cijfers zijn toegestaan s
None	Het element integrale cijfers alleen.
AllowDecimalPoint	De decimale puntelementen (.) en fractionele cijfers .
AllowExponent	Het teken "e" of "E", dat een exponentiële notatie aangeeft. Deze vlag ondersteunt op zichzelf waarden in deformuliercijfers E-cijfers; er zijn extra vlaggen nodig om tekenreeksen te parseren met elementen zoals positieve of negatieve tekens en decimale kommasymbolen.
AllowLeadingWhite	Het ws-element aan het begin van s.
AllowTrailingWhite	Het ws-element aan het einde van s.
AllowLeadingSign	Het tekenelement aan het begin van s.
AllowTrailingSign	Het tekenelement aan het einde van s.
AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
AllowThousands	Het scheidingsteken voor duizendtallen (,)
AllowCurrencySymbol	Het valutaelement ($).
Currency	Alle elementen. s Kan echter geen hexadecimaal getal of een getal in exponentiële notatie vertegenwoordigen.
Float	Het ws-element aan het begin of einde van s, het teken aan het begin van sen het decimaalteken (.). De s parameter kan ook exponentiële notatie gebruiken.
Number	De wselementen , signscheidingsteken voor duizendtallen (,) en decimaalteken (.).
Any	Alle elementen. s Kan echter geen hexadecimaal getal vertegenwoordigen.

De provider parameter is een IFormatProvider implementatie. De GetFormat methode retourneert een NumberFormatInfo object dat cultuurspecifieke informatie biedt over de indeling van value. provider Dit kan meestal een van de volgende zijn:

• Een CultureInfo object dat de cultuur vertegenwoordigt die numerieke opmaakgegevens biedt. De GetFormat methode retourneert het NumberFormatInfo object dat numerieke opmaakgegevens levert.

• Een NumberFormatInfo object dat opmaakinformatie biedt. (De implementatie van GetFormat alleen retourneert zichzelf.)

• Een aangepast object dat de methode implementeert IFormatProvider en gebruikt om het GetFormatNumberFormatInfo object te instantiëren en te retourneren dat opmaakinformatie biedt.

Als provider dat het is null, wordt het NumberFormatInfo object voor de huidige cultuur gebruikt.

Als s buiten het bereik van het gegevenstype Single valt, genereert de methode een OverflowException in .NET Framework. In .NET Core 3.0 en latere versies wordt Single.NegativeInfinity geretourneerd als s kleiner is dan Single.MinValue en Single.PositiveInfinity als s groter is dan Single.MaxValue.

Als er tijdens een parseringsbewerking een scheidingsteken wordt aangetroffen in de s parameter en de toepasselijke valuta- of getaldecimaaltekens en groepsscheidingstekens hetzelfde zijn, wordt bij de parseringsbewerking ervan uitgegaan dat het scheidingsteken een decimaalteken is in plaats van een scheidingsteken voor groepen. Zie , CurrencyDecimalSeparator, en NumberDecimalSeparatorCurrencyGroupSeparatorvoor meer informatie over scheidingstekens NumberGroupSeparator.

Zie ook

• ToString()
• Parsing Numerieke tekenreeksen in .NET