Double.TryParse Metod

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

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

Parametrar

Returer

trueom s har parsats, annars . false

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Double) 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:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

static member TryParse : string * double -> bool

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

Parametrar

Returer

true om s har konverterats, annars false.

Exempel

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

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "1,643.57", "$1,643.57", "-1.643e6",
                          "-168934617882109132", "123AE6",
                          null, String.Empty, "ABCDEF" };
      double number;

      foreach (var value in values) {
         if (Double.TryParse(value, out number))
            Console.WriteLine("'{0}' --> {1}", value, number);
         else
            Console.WriteLine("Unable to parse '{0}'.", value);
      }
   }
}
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.

open System

let values =
    [| "1,643.57"; "$1,643.57"; "-1.643e6"
       "-168934617882109132"; "123AE6"
       null; String.Empty; "ABCDEF" |]

for value in values do
    match Double.TryParse value with
    | true, number ->
        printfn $"'{value}' --> {number}"
    | _ ->
        printfn $"Unable to parse '{value}'."
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.

Module Example
   Public Sub Main()
      Dim values() As String = { "1,643.57", "$1,643.57", "-1.643e6", 
                                "-168934617882109132", "123AE6", 
                                Nothing, String.Empty, "ABCDEF" }
      Dim number As Double
      
      For Each value In values
         If Double.TryParse(value, number) Then
            Console.WriteLine("'{0}' --> {1}", value, number)
         Else
            Console.WriteLine("Unable to parse '{0}'.", value)      
         End If   
      Next   
   End Sub
End Module
' The example displays the following output:
'       '1,643.57' --> 1643.57
'       Unable to parse '$1,643.57'.
'       '-1.643e6' --> -1643000
'       '-168934617882109132' --> -1.68934617882109E+17
'       Unable to parse '123AE6'.
'       Unable to parse ''.
'       Unable to parse ''.
'       Unable to parse 'ABCDEF'.

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 Double.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 den aktuella kulturens NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymboleller NumberFormatInfo.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.

Mer information om numeriska format finns i Formateringstyper.

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 Double.TryParse(String, NumberStyles, IFormatProvider, Double) 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 Double.TryParse(String, NumberStyles, IFormatProvider, Double) metodens överlagring.

Normalt returneras det ursprungliga Double.TryParse värdet om du skickar Double.ToString metoden en sträng som skapas genom att anropa Double metoden. Men på grund av en förlust av precision kanske värdena inte är lika med. Dessutom kan försök att parsa strängrepresentationen av antingen Double.MinValue eller Double.MaxValue misslyckas med att tur och retur. På .NET Framework genererar den en OverflowException. I .NET Core 3.0 och senare versioner returneras Double.NegativeInfinity om du försöker parsa MinValue eller Double.PositiveInfinity om du försöker parsa MaxValue. I följande exempel visas en bild.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

Om ligger inom intervallet för datatypen i .NET genererar metoden < .

I .NET Core 3.0 och senare versioner utlöses inget undantag när s ligger inom intervallet för datatypen Double. I de flesta fall TryParse(String, Double) beräknar metoden ett resultat av Double.PositiveInfinity eller Double.NegativeInfinity. Det finns dock en liten uppsättning värden som anses ligga närmare max- eller minimivärdena Double för än positiv eller negativ oändlighet. I dessa fall beräknar metoden ett resultat av Double.MaxValue eller Double.MinValue.

Om en avgränsare påträffas i parametern s under en parsningsåtgärd, och decimal- och gruppavgränsarna ä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
• Exempel: Formateringsverktyget för .NET Core WinForms (C#)
• Exempel: Formateringsverktyget för .NET Core WinForms (Visual Basic)

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

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

Parametrar

Returer

trueom utf8Text har parsats, annars . false

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

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

Parametrar

Returer

trueom s har parsats, annars . false

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

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

Parametrar

Returer

trueom utf8Text har parsats, annars . false

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

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

Parametrar

Returer

true om utf8Text har konverterats, annars false.

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

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

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Double) 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:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

Källa:

Double.cs

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

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

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

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

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

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

Parametrar

Returer

true om s har konverterats, annars false.

Undantag

Exempel

I följande exempel visas hur metoden används Double.TryParse(String, NumberStyles, IFormatProvider, Double) 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;
NumberStyles style;
CultureInfo culture;
double number;

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

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

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

value = "1 345,978";
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Unable to convert '1 345,978'.

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

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

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

let value = "1 345,978"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Unable to convert '1 345,978'.

Dim value As String
Dim style As NumberStyles
Dim culture As CultureInfo
Dim number As Double

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

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

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

value = "1 345,978"
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays:
'       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.

Metoden TryParse liknar Parse(String, NumberStyles, IFormatProvider) metoden, förutom att den här metoden inte utlöser ett undantag om konverteringen misslyckas. Om konverteringen lyckas är true returvärdet och parametern result är inställd på resultatet av konverteringen. Om konverteringen misslyckas är false returvärdet och parametern result är inställd på noll. Detta 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 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 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 Double . 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, till exempel ett objekt eller NumberFormatInfo ett CultureInfo objekt. Parametern provider tillhandahåller kulturspecifik information som används vid parsning. Om provider is null eller ett NumberFormatInfo objekt inte kan hämtas används formatinformationen för den aktuella kulturen.

Konverteringen misslyckas om parametern s är eller inte är null ett numeriskt värde, parametern provider inte ger ett NumberFormatInfo objekt eller om parametern style inte är en kombination av bitflaggor från NumberStyles uppräkningen.

Normalt returneras det ursprungliga Double.TryParse värdet om du skickar Double.ToString metoden en sträng som skapas genom att anropa Double metoden. Men på grund av en förlust av precision kanske värdena inte är lika med. Dessutom kan försök att parsa strängrepresentationen av antingen Double.MinValue eller Double.MaxValue misslyckas med att tur och retur. På .NET Framework genererar den en OverflowException. I .NET Core 3.0 och senare versioner returneras Double.NegativeInfinity om du försöker parsa MinValue eller Double.PositiveInfinity om du försöker parsa MaxValue. I följande exempel visas en bild.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

Om ligger inom intervallet för datatypen i .NET genererar metoden < .

I .NET Core 3.0 och senare versioner utlöses inget undantag när s ligger inom intervallet för datatypen Double. I de flesta fall Double.TryParse(String, NumberStyles, IFormatProvider, Double) beräknar metoden ett resultat av Double.PositiveInfinity eller Double.NegativeInfinity. Det finns dock en liten uppsättning värden som anses ligga närmare max- eller minimivärdena Double för än positiv eller negativ oändlighet. I dessa fall beräknar metoden ett resultat av Double.MaxValue eller Double.MinValue.

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

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