Single.Parse Metod

Definition

Namnområde:: System

Sammansättningar:: mscorlib.dll, System.Runtime.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Konverterar strängrepresentationen av ett tal till dess flyttalsnummer med enkel precision.

Överlagringar

Name	Description
Parse(String)	Konverterar strängrepresentationen av ett tal till dess flyttalsnummer med enkel precision.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsar ett teckenintervall till ett värde.
Parse(String, NumberStyles)	Konverterar strängrepresentationen av ett tal i ett angivet format till dess flytande punktnummer med enkel precision.
Parse(String, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess flytande punktnummer med enkel precision.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konverterar ett teckenintervall som innehåller strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess flytande punktnummer med enkel precision.
Parse(String, NumberStyles, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess flytande punktnummer med enkel precision.

Kommentarer

I .NET Core 3.0 och senare avrundas värden som är för stora för att representera till PositiveInfinity eller NegativeInfinity enligt IEEE 754-specifikationen. I tidigare versioner, inklusive .NET Framework, resulterade parsning av ett värde som var för stort för att representera ett fel.

Parse(String)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Konverterar strängrepresentationen av ett tal till dess flyttalsnummer med enkel precision.

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

Parametrar

s: String

En sträng som innehåller ett tal som ska konverteras.

Returer

Single

Ett flyttal med enkel precision som motsvarar det numeriska värdet eller symbolen som anges i s.

Undantag

ArgumentNullException

s är null.

FormatException

s representerar inte ett tal i ett giltigt format.

OverflowException

endast .NET Framework: s representerar ett tal som är mindre än Single.MinValue eller större än Single.MaxValue.

Exempel

I följande exempel används Parse(String) metoden för att konvertera en matris med strängar till motsvarande Single värden.

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.

Kommentarer

Parametern s kan innehålla den aktuella kulturens PositiveInfinitySymbol, NegativeInfinitySymboleller NaNSymbol symbol. Den här strängjämförelsen är skiftlägeskänslig i .NET Core 3.0 och senare versioner, men är skiftlägeskänslig i tidigare versioner, inklusive .NET Framework. Parametern s kan också vara en sträng i formuläret:

[ws][sign] [integral-digits[,]]integral-digits[.[bråktalssiffror]][e[sign]exponentiella siffror][ws]

Element inom hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	En serie blankstegstecken.
signera	En negativ teckensymbol eller en positiv teckensymbol. Giltiga teckentecken bestäms av NumberFormatInfo.NegativeSign egenskaperna och NumberFormatInfo.PositiveSign för den aktuella kulturen. Endast ett inledande tecken kan användas.
integral-digits	En serie siffror från 0 till 9 som anger den integrerade delen av talet. Körningar av integral-digits kan partitioneras med en gruppavgränsningssymbol. I vissa kulturer separerar till exempel ett kommatecken (,) grupper på tusentals. Elementet integral-digits kan saknas om strängen innehåller elementet fractional-digits .
,	En kulturspecifik tusentalsavgränsare.
.	Ett kulturspecifikt decimaltecken.
fractional-digits	En serie siffror från 0 till 9 som anger bråkdelen av talet.
E	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation.
exponentiella siffror	En serie siffror från 0 till 9 som anger en exponent.

Parametern s tolkas med hjälp av en kombination av flaggorna NumberStyles.Float och NumberStyles.AllowThousands . Det innebär att blanksteg och tusentalsavgränsare tillåts, men inte valutasymboler. Om du uttryckligen vill definiera de element (till exempel valutasymboler, tusentalsavgränsare och blanksteg) som kan finnas i sanvänder du Parse(String, NumberStyles) metodens överbelastning.

Parametern s parsas med hjälp av formateringsinformationen i ett NumberFormatInfo objekt som initieras för den aktuella systemkulturen. Mer information finns i CurrentInfo. Om du vill parsa en sträng med hjälp av formateringsinformationen för en viss kultur använder du Parse(String, IFormatProvider) metoden eller Parse(String, NumberStyles, IFormatProvider) .

Normalt returneras det ursprungliga Parse värdet om du skickar ToString metoden en sträng som skapas genom att anropa Single metoden. Men på grund av en förlust av precision kanske värdena inte är lika med.

Om s ligger inom intervallet för datatypen Single genererar metoden en OverflowException på .NET Framework. I .NET Core 3.0 och senare versioner returneras Single.NegativeInfinity om s är mindre än Single.MinValue och Single.PositiveInfinity om s är större än Single.MaxValue.

Om en avgränsare påträffas i parametern s under en parsningsåtgärd och tillämpliga decimaler för valuta eller tal och gruppavgränsare är desamma, förutsätter parsningsåtgärden att avgränsaren är en decimalavgränsare i stället för en gruppavgränsare. Mer information om avgränsare finns i CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatoroch NumberGroupSeparator.

Se även

Gäller för

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Parsar ett intervall med UTF-8 tecken till ett värde.

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

Parametrar

utf8Text: ReadOnlySpan<Byte>

Intervallet för UTF-8 tecken att parsa.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om utf8Text.

Returer

Single

Resultatet av parsning utf8Text.

Implementeringar

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Gäller för

Parse(ReadOnlySpan<Char>, IFormatProvider)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Parsar ett teckenintervall till ett värde.

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

Parametrar

s: ReadOnlySpan<Char>

Det intervall med tecken som ska parsas.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

Returer

Single

Resultatet av parsning s.

Implementeringar

Parse(ReadOnlySpan<Char>, IFormatProvider)

Gäller för

Parse(String, NumberStyles)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Konverterar strängrepresentationen av ett tal i ett angivet format till dess flytande punktnummer med enkel precision.

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

Parametrar

s: String

En sträng som innehåller ett tal som ska konverteras.

style: NumberStyles

En bitvis kombination av uppräkningsvärden som anger de formatelement som kan finnas i s. Ett typiskt värde att ange kombineras Float med AllowThousands.

Returer

Single

Ett flyttal med enkel precision som motsvarar det numeriska värdet eller symbolen som anges i s.

Undantag

ArgumentNullException

s är null.

FormatException

s är inte ett tal i ett giltigt format.

OverflowException

endast .NET Framework: s representerar ett tal som är mindre än Single.MinValue eller större än Single.MaxValue.

ArgumentException

style är inte ett NumberStyles värde.

-eller-

style innehåller värdet AllowHexSpecifier .

Exempel

I följande exempel används Parse(String, NumberStyles) metoden för att parsa strängrepresentationerna av Single värden. I exemplet används formateringsinformation för en-US kultur.

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.

Kommentarer

Parametern style definierar formatelementen (till exempel blanksteg, tusentalsavgränsare och valutasymboler) som tillåts i parametern s för att parsningsåtgärden ska lyckas. Det måste vara en kombination av bitflaggor från NumberStyles uppräkningen. Följande NumberStyles medlemmar stöds inte:

Parametern s kan innehålla den aktuella kulturens PositiveInfinitySymbol, NegativeInfinitySymboleller NaNSymbol symbol. Den här strängjämförelsen är skiftlägeskänslig i .NET Core 3.0 och senare versioner, men är skiftlägeskänslig i tidigare versioner, inklusive .NET Framework. Beroende på värdet för stylekan parametern s också ha formuläret:

[ws][$][sign][integral-digits[,]]integral-digits[.[bråktalssiffror]][E[sign]exponentiella siffror][ws]

Element inom hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Ws En serie blankstegstecken. Tomt utrymme kan visas i början av s om style innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av s om style innehåller NumberStyles.AllowTrailingWhite flaggan.

$ En kulturspecifik valutasymbol. Dess position i strängen definieras av NumberFormatInfo.CurrencyNegativePattern egenskaperna och NumberFormatInfo.CurrencyPositivePattern för den aktuella kulturen. Den aktuella kulturens valutasymbol kan visas i s om style den NumberStyles.AllowCurrencySymbol innehåller flaggan.

Tecken Ett negativt tecken (-) eller ett positivt tecken (+). Tecknet kan visas i början av s om style innehåller NumberStyles.AllowLeadingSign flaggan, och det kan visas i slutet av s om style innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i s för att ange ett negativt värde om style den NumberStyles.AllowParentheses innehåller flaggan.

integral-digits En serie siffror från 0 till 9 som anger den integrerade delen av talet. Elementet integral-digits kan saknas om strängen innehåller elementet fractional-digits .

, En kulturspecifik gruppavgränsare. Den aktuella kulturens gruppavgränsarsymbol kan visas i s om style den NumberStyles.AllowThousands innehåller flaggan

. Ett kulturspecifikt decimaltecken. Den aktuella kulturens decimaltecken kan visas i s om style den NumberStyles.AllowDecimalPoint innehåller flaggan.

fractional-digits En serie siffror från 0 till 9 som anger bråkdelen av talet. Bråksiffror kan visas i s om style den NumberStyles.AllowDecimalPoint innehåller flaggan.

E Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation. Parametern value kan representera ett tal i exponentiell notation om style den NumberStyles.AllowExponent innehåller flaggan.

exponentiella siffror En serie siffror från 0 till 9 som anger en exponent.

Note

Alla avslutande NUL-tecken (U+0000) i s ignoreras av parsningsåtgärden, oavsett argumentets style värde.

En sträng med endast siffror (vilket motsvarar NumberStyles.None formatet) parsar alltid korrekt om den är i typintervallet Single . De återstående System.Globalization.NumberStyles medlemmarna styr element som kan finnas, men som inte måste finnas, i indatasträngen. I följande tabell visas hur enskilda NumberStyles flaggor påverkar de element som kan finnas i s.

NumberStyles-värde	Element som tillåts `s` utöver siffror
None	Elementet integral-digits .
AllowDecimalPoint	Decimaltecknet (.) och bråksiffriga element.
AllowExponent	Tecknet "e" eller "E", som indikerar exponentiell notation. Den här flaggan stöder i sig värden i formuläret siffrorE-siffror; ytterligare flaggor behövs för att parsa strängar med element som positiva eller negativa tecken och decimaltecken.
AllowLeadingWhite	WS-elementet i början av `s`.
AllowTrailingWhite	WS-elementet i slutet av `s`.
AllowLeadingSign	Teckenelementet i början av `s`.
AllowTrailingSign	Teckenelementet i slutet av `s`.
AllowParentheses	Teckenelementet i form av parenteser som omger det numeriska värdet.
AllowThousands	Elementet tusentalsavgränsare (,).
AllowCurrencySymbol	Valutaelementet ($).
Currency	Alla element. Kan dock `s` inte representera ett hexadecimalt tal eller ett tal i exponentiell notation.
Float	WS-elementet i början eller slutet av `s`, tecknet i början av `s`och decimaltecknet (.). Parametern `s` kan också använda exponentiell notation.
Number	Elementen `ws`, `sign`, tusentalsavgränsare (,) och decimaltecken (.).
Any	Alla element. Kan dock `s` inte representera ett hexadecimalt tal.

Några exempel s på är "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" och "-Infinity".

Parametern s parsas med formateringsinformationen i ett NumberFormatInfo objekt som initieras för den aktuella systemkulturen. Om du vill ange den kultur vars formateringsinformation används för parsningsåtgärden anropar du överlagringen Parse(String, NumberStyles, IFormatProvider) .

Se även

Gäller för

Parse(String, IFormatProvider)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess flytande punktnummer med enkel precision.

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

Parametrar

s: String

En sträng som innehåller ett tal som ska konverteras.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

Returer

Single

Ett flyttal med enkel precision som motsvarar det numeriska värdet eller symbolen som anges i s.

Implementeringar

Parse(String, IFormatProvider)

Undantag

ArgumentNullException

s är null.

FormatException

s representerar inte ett tal i ett giltigt format.

OverflowException

endast .NET Framework: s representerar ett tal som är mindre än Single.MinValue eller större än Single.MaxValue.

Exempel

Följande exempel är knappklickshändelsehanteraren för ett webbformulär. Den använder matrisen som returneras av HttpRequest.UserLanguages egenskapen för att fastställa användarens nationella inställningar. Det instansierar sedan ett CultureInfo objekt som motsvarar det nationella språket. Objektet NumberFormatInfo som tillhör objektet CultureInfo skickas sedan till Parse(String, IFormatProvider) metoden för att konvertera användarens indata till ett Single värde.

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

Kommentarer

Den här överlagringen används vanligtvis för att konvertera text som kan formateras på flera olika sätt till ett Single värde. Den kan till exempel användas för att konvertera texten som en användare har angett till en HTML-textruta till ett numeriskt värde.

Parametern s tolkas med hjälp av en kombination av flaggorna NumberStyles.Float och NumberStyles.AllowThousands . Parametern s kan innehålla NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymboleller NumberFormatInfo.NaNSymbol symbol för den kultur som anges av provider. Den här strängjämförelsen är skiftlägeskänslig i .NET Core 3.0 och senare versioner, men är skiftlägeskänslig i tidigare versioner, inklusive .NET Framework. Parametern s kan innehålla en sträng i formuläret:

[ws][sign]integral-digits[.[bråktalssiffror]][E[sign]exponentiella siffror][ws]

Valfria element är inramade inom hakparenteser ([ och ]). Element som innehåller termen "siffror" består av en serie numeriska tecken från 0 till 9.

Element	Description
Ws	En serie blankstegstecken.
signera	Ett negativt tecken (-) eller ett positivt tecken (+).
integral-digits	En serie siffror från 0 till 9 som anger den integrerade delen av talet. Körningar av integral-digits kan partitioneras med en gruppavgränsningssymbol. I vissa kulturer separerar till exempel ett kommatecken (,) grupper på tusentals. Elementet integral-digits kan saknas om strängen innehåller elementet fractional-digits .
.	Ett kulturspecifikt decimaltecken.
fractional-digits	En serie siffror från 0 till 9 som anger bråkdelen av talet.
E	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation.
exponentiella siffror	En serie siffror från 0 till 9 som anger en exponent.

Mer information om numeriska format finns i avsnittet Formateringstyper .

Parametern provider är en IFormatProvider implementering vars GetFormat metod returnerar ett NumberFormatInfo objekt som tillhandahåller kulturspecifik formateringsinformation. Parse(String, IFormatProvider) När metoden anropas anropas provider parameterns GetFormat metod och skickar den ett Type objekt som representerar NumberFormatInfo typen. Metoden GetFormat returnerar sedan objektet NumberFormatInfo som innehåller information om parameterns s format. Det finns tre sätt att använda parametern provider för att ange anpassad formateringsinformation till parsningsåtgärden:

Du kan skicka ett CultureInfo objekt som representerar kulturen som tillhandahåller formateringsinformation. Dess GetFormat metod returnerar det NumberFormatInfo objekt som innehåller numerisk formateringsinformation för den kulturen.
Du kan skicka det faktiska NumberFormatInfo objektet som innehåller numerisk formateringsinformation. (Dess implementering av GetFormat just returnerar sig själv.)
Du kan skicka ett anpassat objekt som implementerar IFormatProvider. Metoden GetFormat instansierar och returnerar objektet NumberFormatInfo som tillhandahåller formateringsinformation.

Om provider är null eller inte NumberFormatInfo kan hämtas används formateringsinformationen för den aktuella systemkulturen.

Några exempel s på är "100", "-123,456,789", "123.45e+6", "+500", "5e2", "3.1416", "600.", "-.123" och "-Infinity".

Se även

Gäller för

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Parsar ett intervall med UTF-8 tecken till ett värde.

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

Parametrar

utf8Text: ReadOnlySpan<Byte>

Intervallet för UTF-8 tecken att parsa.

style: NumberStyles

En bitvis kombination av talformat som kan finnas i utf8Text.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om utf8Text.

Returer

Single

Resultatet av parsning utf8Text.

Implementeringar

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Gäller för

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Konverterar ett teckenintervall som innehåller strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess flytande punktnummer med enkel precision.

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

Parametrar

s: ReadOnlySpan<Char>

Ett teckenintervall som innehåller talet som ska konverteras.

style: NumberStyles

En bitvis kombination av uppräkningsvärden som anger de formatelement som kan finnas i s. Ett typiskt värde att ange kombineras Float med AllowThousands.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

Returer

Single

Ett flyttal med enkel precision som motsvarar det numeriska värdet eller symbolen som anges i s.

Implementeringar

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Undantag

FormatException

s representerar inte ett numeriskt värde.

ArgumentException

style är inte ett NumberStyles värde.

-eller-

style är värdet AllowHexSpecifier .

Kommentarer

Om s är utom datatypens intervall Single returnerar Single.NegativeInfinity metoden om s den är mindre än Single.MinValue och Single.PositiveInfinity om s är större än Single.MaxValue.

Gäller för

Parse(String, NumberStyles, IFormatProvider)

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Källa:: Single.cs

Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess flytande punktnummer med enkel precision.

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

Parametrar

s: String

En sträng som innehåller ett tal som ska konverteras.

style: NumberStyles

En bitvis kombination av uppräkningsvärden som anger de formatelement som kan finnas i s. Ett typiskt värde att ange kombineras Float med AllowThousands.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

Returer

Single

Ett flyttal med enkel precision som motsvarar det numeriska värdet eller symbolen som anges i s.

Implementeringar

Parse(String, NumberStyles, IFormatProvider)

Undantag

ArgumentNullException

s är null.

FormatException

s representerar inte ett numeriskt värde.

ArgumentException

style är inte ett NumberStyles värde.

-eller-

style är värdet AllowHexSpecifier .

OverflowException

endast .NET Framework: s representerar ett tal som är mindre än Single.MinValue eller större än Single.MaxValue.

Exempel

I följande kodexempel används Parse(String, NumberStyles, IFormatProvider) metoden för att parsa strängrepresentationerna av Single värden. Varje sträng i en matris parsas med formateringskonventionerna för en-US, nl-NLoch en anpassad kultur. Den anpassade kulturen definierar dess gruppavgränsarsymbol som understreck ("_") och dess gruppstorlek som två.

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.

Kommentarer

Parametern s kan innehålla NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymboleller NumberFormatInfo.NaNSymbol symbol för den kultur som anges av provider. Den här strängjämförelsen är skiftlägeskänslig i .NET Core 3.0 och senare versioner, men är skiftlägeskänslig i tidigare versioner, inklusive .NET Framework. Beroende på värdet för stylekan parametern s också ha formuläret:

[ws] [$] [sign][integral-digits,]integral-digits[.[ fractional-digits]][E[sign]exponentiella siffror][ws]

Element inramade i hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	En serie blankstegstecken. Tomt utrymme kan visas i början av `s` om `style` innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av `s` om `style` innehåller NumberStyles.AllowTrailingWhite flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av NumberFormatInfo.CurrencyNegativePattern egenskaperna och NumberFormatInfo.CurrencyPositivePattern för den aktuella kulturen. Den aktuella kulturens valutasymbol kan visas i `s` om `style` den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett negativt tecken (-) eller ett positivt tecken (+). Tecknet kan visas i början av `s` om `style` innehåller NumberStyles.AllowLeadingSign flaggan, och det kan visas i slutet av `s` om `style` innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i `s` för att ange ett negativt värde om `style` den NumberStyles.AllowParentheses innehåller flaggan.
integral-digits	En serie siffror från 0 till 9 som anger den integrerade delen av talet. Elementet integral-digits kan saknas om strängen innehåller elementet fractional-digits .
,	En kulturspecifik gruppavgränsare. Den aktuella kulturens gruppavgränsarsymbol kan visas i `s` om `style` den NumberStyles.AllowThousands innehåller flaggan
.	Ett kulturspecifikt decimaltecken. Den aktuella kulturens decimaltecken kan visas i `s` om `style` den NumberStyles.AllowDecimalPoint innehåller flaggan.
fractional-digits	En serie siffror från 0 till 9 som anger bråkdelen av talet. Bråksiffror kan visas i `s` om `style` den NumberStyles.AllowDecimalPoint innehåller flaggan.
E	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation. Parametern `s` kan representera ett tal i exponentiell notation om `style` den NumberStyles.AllowExponent innehåller flaggan.
exponentiella siffror	En serie siffror från 0 till 9 som anger en exponent.

Note

Alla avslutande NUL-tecken (U+0000) i s ignoreras av parsningsåtgärden, oavsett argumentets style värde.

NumberStyles-värde	Element som tillåts `s` utöver siffror
None	Elementet integral-digits .
AllowDecimalPoint	Decimaltecknet (.) och bråksiffriga element.
AllowExponent	Tecknet "e" eller "E", som indikerar exponentiell notation. Den här flaggan stöder i sig värden i formuläret siffrorE-siffror; ytterligare flaggor behövs för att parsa strängar med element som positiva eller negativa tecken och decimaltecken.
AllowLeadingWhite	WS-elementet i början av `s`.
AllowTrailingWhite	WS-elementet i slutet av `s`.
AllowLeadingSign	Teckenelementet i början av `s`.
AllowTrailingSign	Teckenelementet i slutet av `s`.
AllowParentheses	Teckenelementet i form av parenteser som omger det numeriska värdet.
AllowThousands	Elementet tusentalsavgränsare (,).
AllowCurrencySymbol	Valutaelementet ($).
Currency	Alla element. Kan dock `s` inte representera ett hexadecimalt tal eller ett tal i exponentiell notation.
Float	WS-elementet i början eller slutet av `s`, tecknet i början av `s`och decimaltecknet (.). Parametern `s` kan också använda exponentiell notation.
Number	Elementen `ws`, `sign`, tusentalsavgränsare (,) och decimaltecken (.).
Any	Alla element. Kan dock `s` inte representera ett hexadecimalt tal.

Parametern provider är en IFormatProvider implementering. Dess GetFormat metod returnerar ett NumberFormatInfo objekt som ger kulturspecifik information om formatet valueför . provider Kan vanligtvis vara något av följande:

Ett CultureInfo objekt som representerar kulturen som innehåller numerisk formateringsinformation. Dess GetFormat metod returnerar det NumberFormatInfo objekt som innehåller numerisk formateringsinformation.
Ett NumberFormatInfo objekt som innehåller formateringsinformation. (Dess implementering av GetFormat just returnerar sig själv.)
Ett anpassat objekt som implementerar IFormatProvider och använder GetFormat metoden för att instansiera och returnera det NumberFormatInfo objekt som tillhandahåller formateringsinformation.

Om provider är nullNumberFormatInfo används objektet för den aktuella kulturen.

Se även

Gäller för

Feedback

Var den här sidan till hjälp?