Single.TryParse Metod

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = IParsable<float>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out float result);

static member TryParse : string * IFormatProvider * single -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Single) As Boolean

Parametrar

Returer

trueom s har parsats, annars . false

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] float % result);

public static bool TryParse(ReadOnlySpan<char> s, out float result);

static member TryParse : ReadOnlySpan<char> * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Single) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

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.

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] float % result);

public static bool TryParse(string s, out float result);

public static bool TryParse(string? s, out float result);

static member TryParse : string * single -> bool

Public Shared Function TryParse (s As String, ByRef result As Single) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Exempel

I följande exempel används TryParse(String, Single) metoden för att konvertera strängrepresentationer av numeriska värden till Single värden. Det förutsätter att en-US är den nuvarande kulturen.

string value;
float number;

// Parse a floating-point value with a thousands separator.
value = "1,643.57";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse a floating-point value with a currency symbol and a
// thousands separator.
value = "$1,643.57";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse value in exponential notation.
value = "-1.643e6";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);

// Parse a negative integer value.
value = "-168934617882109132";
if (Single.TryParse(value, out number))
   Console.WriteLine(number);
else
   Console.WriteLine("Unable to parse '{0}'.", value);
// The example displays the following output:
//       1643.57
//       Unable to parse '$1,643.57'.
//       -164300
//       -1.689346E+17

// Parse a floating-point value with a thousands separator.
let value = "1,643.57"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse a floating-point value with a currency symbol and a
// thousands separator.
let value = "$1,643.57"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse value in exponential notation.
let value = "-1.643e6"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."

// Parse a negative integer value.
let value = "-168934617882109132"
match Single.TryParse value with
| true, number ->
    printfn $"{number}"
| _ ->
    printfn $"Unable to parse '{value}'."
// The example displays the following output:
//       1643.57
//       Unable to parse '$1,643.57'.
//       -164300
//       -1.689346E+17

Dim value As String
Dim number As Single

' Parse a floating-point value with a thousands separator.
value = "1,643.57"
If Single.TryParse(value, number) Then
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse a floating-point value with a currency symbol and a
' thousands separator.
value = "$1,643.57"
If Single.TryParse(value, number) Then
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse value in exponential notation.
value = "-1.643e6"
If Single.TryParse(value, number)
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If

' Parse a negative integer number.
value = "-168934617882109132"
If Single.TryParse(value, number)
   Console.WriteLine(number)
Else
   Console.WriteLine("Unable to parse '{0}'.", value)
End If
' The example displays the following output:
'       1643.57
'       Unable to parse '$1,643.57'.
'       -1643000
'       -1.689346E+17

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.

Den här överlagringen Single.Parse(String) skiljer sig från metoden genom att returnera ett booleskt värde som anger om parsningsåtgärden lyckades i stället för att returnera det parsade numeriska värdet. Det eliminerar behovet av att använda undantagshantering för att testa för en FormatException i händelse av att s den är ogiltig och inte kan parsas.

Parametern s kan innehålla 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[.[ fractional-digits]][e[sign]exponential-digits][ws]

Element inom hakparenteser är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	En serie blankstegstecken.
signera	Ett negativt tecken eller ett positivt tecken.
integral-digits	En serie numeriska tecken från 0 till 9 som anger den integrerade delen av talet. Integral-digits kan saknas om det finns bråktalssiffror.
,	En kulturspecifik gruppavgränsare.
.	Ett kulturspecifikt decimaltecken.
fractional-digits	En serie numeriska tecken från 0 till 9 som anger bråkdelen av talet.
E	Ett versaler eller gemener som anger exponentiell (vetenskaplig) notation.
exponentiella siffror	En serie numeriska tecken 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 TryParse(String, NumberStyles, IFormatProvider, Single) metodens överbelastning.

Parametern s parsas med formateringsinformationen i ett NumberFormatInfo objekt som initieras för den aktuella systemkulturen. Mer information finns i NumberFormatInfo.CurrentInfo. Om du vill parsa en sträng med formateringsinformationen för någon annan angiven kultur använder du TryParse(String, NumberStyles, IFormatProvider, Single) metodens överlagring.

Normalt returneras det ursprungliga Single.TryParse värdet om du skickar Single.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 returnerar metoden false 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

• Parse(String)
• ToString()
• Parsing Numeriska strängar i .NET

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = IUtf8SpanParsable<float>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Single) As Boolean

Parametrar

Returer

trueom utf8Text har parsats, annars . false

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = ISpanParsable<float>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Single) As Boolean

Parametrar

Returer

trueom s har parsats, annars . false

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

Parametrar

Returer

trueom utf8Text har parsats, annars . false

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] float % result);

public static bool TryParse(ReadOnlySpan<byte> utf8Text, out float result);

static member TryParse : ReadOnlySpan<byte> * single -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Single) As Boolean

Parametrar

Returer

true om utf8Text har konverterats, annars false.

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out float result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * single -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

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.

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

Källa:

Single.cs

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result);

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] float % result) = System::Numerics::INumberBase<float>::TryParse;

public static bool TryParse(string s, System.Globalization.NumberStyles style, IFormatProvider provider, out float result);

public static bool TryParse(string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out float result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * single -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Single) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Undantag

Exempel

I följande exempel visas hur metoden används Single.TryParse(String, NumberStyles, IFormatProvider, Single) för att parsa strängrepresentationen av tal som har ett visst format och formateras med hjälp av konventionerna i en viss kultur.

string value;
System.Globalization.NumberStyles style;
System.Globalization.CultureInfo culture;
float number;

// Parse currency value using en-GB culture.
value = "£1,097.63";
style = System.Globalization.NumberStyles.Number |
        System.Globalization.NumberStyles.AllowCurrencySymbol;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1345,978";
style = System.Globalization.NumberStyles.AllowDecimalPoint;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1.345,978";
style = System.Globalization.NumberStyles.AllowDecimalPoint |
        System.Globalization.NumberStyles.AllowThousands;
culture = System.Globalization.CultureInfo.CreateSpecificCulture("es-ES");
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);

value = "1 345,978";
if (Single.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// The example displays the following output:
//       Converted '£1,097.63' to 1097.63.
//       Converted '1345,978' to 1345.978.
//       Converted '1.345,978' to 1345.978.
//       Unable to convert '1 345,978'.

// Parse currency value using en-GB culture.
let value = "£1,097.63"
let style = System.Globalization.NumberStyles.Number ||| System.Globalization.NumberStyles.AllowCurrencySymbol
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1345,978"
let style = System.Globalization.NumberStyles.AllowDecimalPoint
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1.345,978"
let style = System.Globalization.NumberStyles.AllowDecimalPoint ||| System.Globalization.NumberStyles.AllowThousands
let culture = System.Globalization.CultureInfo.CreateSpecificCulture "es-ES"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."

let value = "1 345,978"
match Single.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// The example displays the following output:
//       Converted '£1,097.63' to 1097.63.
//       Converted '1345,978' to 1345.978.
//       Converted '1.345,978' to 1345.978.
//       Unable to convert '1 345,978'.

Dim value As String
Dim style As System.Globalization.NumberStyles
Dim culture As System.Globalization.CultureInfo
Dim number As Single

' Parse currency value using en-GB culture.
value = "£1,097.63"
style = System.Globalization.NumberStyles.Number Or _
        System.Globalization.NumberStyles.AllowCurrencySymbol
culture = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1345,978"
style = System.Globalization.NumberStyles.AllowDecimalPoint
culture = System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1.345,978"
style = System.Globalization.NumberStyles.AllowDecimalPoint Or _
        System.Globalization.NumberStyles.AllowThousands
culture = System.Globalization.CultureInfo.CreateSpecificCulture("es-ES")
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If

value = "1 345,978"
If Single.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If
' The example displays the following output:
'       Converted '£1,097.63' to 1097.63.
'       Converted '1345,978' to 1345.978.
'       Converted '1.345,978' to 1345.978.
'       Unable to convert '1 345,978'.

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.

Den här överlagringen Parse(String, NumberStyles, IFormatProvider) skiljer sig från metoden genom att returnera ett booleskt värde som anger om parsningsåtgärden lyckades i stället för att returnera det parsade numeriska värdet. Det eliminerar behovet av att använda undantagshantering för att testa för en FormatException i händelse av att s den är ogiltig och inte kan parsas.

Parametern style definierar det tillåtna formatet för 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:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

Parametern s kan innehålla PositiveInfinitySymbol, NegativeInfinitySymboleller 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 styleför kan parametern s dessutom innehålla följande element:

[ws] [$] [sign][integral-digits,]integral-digits[.fractional-digits][e[sign]exponential-digits][ws]

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

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av s om style innehåller NumberStyles.AllowLeadingWhite flaggan. Den kan visas i slutet av s om style den NumberStyles.AllowTrailingWhite innehåller flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av NumberFormatInfo.CurrencyNegativePattern egenskaperna eller NumberFormatInfo.CurrencyPositivePattern för objektet som NumberFormatInfo returneras av IFormatProvider.GetFormat parametermetoden provider . Valutasymbolen kan visas i s om style den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt 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. Integral-digits kan saknas om det finns bråktalssiffror.
,	En kulturspecifik tusentalsavgränsare. Den aktuella kulturens tusentalsavgrä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 s det kan representera ett tal med exponentiell notation. Parametern s kan representera ett tal i exponentiell notation om formatet innehåller NumberStyles.AllowExponent flaggan.
exponentiella siffror	En serie siffror från 0 till 9 som anger en exponent.

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 vara men 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 i s utöver siffror
None	Elementet integral-digits .
AllowDecimalPoint	Elementen . och fractional-digits .
AllowExponent	Parametern s kan också använda exponentiell notation. Den här flaggan stöder i sig värden i formatet integral-digitsEexponential-digits; ytterligare flaggor behövs för att parsa strängar i exponentiell notation 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 , .
AllowCurrencySymbol	Elementet $ .
Currency	Alla. Parametern s kan inte representera ett hexadecimalt tal eller ett tal i exponentiell notation.
Float	WS-elementet i början eller slutet av s, signera i början av soch . Parametern s kan också använda exponentiell notation.
Number	Elementen ws, sign, tusentalsavgränsare (,) och decimaltecken (.).
Any	Alla format, förutom s kan inte representera ett hexadecimalt tal.

Parametern provider är en IFormatProvider implementering vars GetFormat metod returnerar ett NumberFormatInfo objekt som tillhandahåller kulturspecifik formateringsinformation. TryParse(String, NumberStyles, IFormatProvider, Single) 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 nulltolkas formateringen för s baserat på objektet i NumberFormatInfo den aktuella kulturen.

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

• Parse(String)
• ToString()
• Parsing Numeriska strängar i .NET