Double.TryParse Methode

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);

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

Parameters

Retouren

trueals s deze is geconverteerd; anders. false

Opmerkingen

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

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::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

Parameters

Retouren

trueals s deze is geconverteerd; anders. false

Voorbeelden

In het volgende voorbeeld wordt de TryParse(String, Double) methode gebruikt om de tekenreeksweergaven van numerieke waarden te converteren naar Double waarden. Hierbij wordt ervan uitgegaan dat en-US de huidige cultuur is.

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'.

Opmerkingen

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

Deze overbelasting verschilt van de Double.Parse(String) methode door een Booleaanse waarde te retourneren die aangeeft of de parseringsbewerking is geslaagd in plaats van de geparseerde numerieke waarde te retourneren. Het elimineert de noodzaak om uitzonderingsafhandeling te gebruiken om te testen op een FormatException in het geval dat s ongeldig is en niet kan worden geparseerd.

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

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

Elementen in vierkante haken zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Een reeks witruimtetekens.
ondertekenen	Een negatief teken of een positief teken.
integral-digits	Een reeks numerieke tekens, variërend van 0 tot 9, waarmee het integraal deel van het getal wordt opgegeven. Integrale cijfers kunnen afwezig zijn als er fractionele cijfers zijn.
,	Een cultuurspecifiek groepsscheidingsteken.
.	Een cultuurspecifiek decimaalteken.
fractionele cijfers	Een reeks numerieke tekens, variërend van 0 tot 9, waarmee het breukgedeelte van het getal wordt opgegeven.
E	Een hoofdletter of kleine letter 'e', dat een exponentiële (wetenschappelijke) notatie aangeeft.
exponentiële cijfers	Een reeks numerieke tekens tussen 0 en 9 die een exponent opgeven.

Zie Opmaaktypen voor meer informatie over numerieke notaties.

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

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

Normaal gesproken wordt de oorspronkelijke Double waarde geretourneerd als u de Double.TryParse methode doorgeeft een tekenreeks die wordt gemaakt door de Double.ToString methode aan te roepen. Vanwege een verlies van precisie zijn de waarden mogelijk niet gelijk. Daarnaast probeert u de tekenreeksweergave van een Double.MinValue van beide te parseren of Double.MaxValue mislukt de retour. In .NET Framework genereert het een OverflowException. In .NET Core 3.0 en latere versies wordt Double.NegativeInfinity geretourneerd als u probeert MinValue of Double.PositiveInfinity te parseren als u probeert MaxValue te parseren. In het volgende voorbeeld ziet u een afbeelding.

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.

Als s in .NET Framework buiten het gegevenstype Double valt, genereert de methode TryParse(String, Double) een OverflowException.

In .NET Core 3.0 en latere versies wordt er geen uitzondering gegenereerd wanneer s buiten het bereik van het gegevenstype Double valt. In de meeste gevallen berekent de TryParse(String, Double) methode een resultaat van Double.PositiveInfinity of Double.NegativeInfinity. Er is echter een kleine set waarden die worden beschouwd als dichter bij de maximum- of minimumwaarden dan Double positieve of negatieve oneindigheid. In die gevallen berekent de methode een resultaat van Double.MaxValue of Double.MinValue.

Als tijdens een parseringsbewerking een scheidingsteken in de s parameter wordt aangetroffen en de scheidingstekens voor decimalen en groepen hetzelfde zijn, wordt bij de parseringsbewerking ervan uitgegaan dat het scheidingsteken een decimaalteken is in plaats van een groepsscheidingsteken. Zie , NumberDecimalSeparator, en NumberGroupSeparatorCurrencyGroupSeparatorvoor meer informatie over scheidingstekens CurrencyDecimalSeparator.

Zie ook

• Parse(String)
• ToString()
• Parsing Numerieke tekenreeksen in .NET
• Voorbeeld: .NET Core WinForms Format Utility (C#)
• Voorbeeld: .NET Core WinForms Format Utility (Visual Basic)

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

Parameters

Retouren

trueals s deze is geconverteerd; anders. false

Opmerkingen

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

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::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

Parameters

Retouren

trueals s deze is geconverteerd; anders. false

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe de methode wordt Double.TryParse(String, NumberStyles, IFormatProvider, Double) gebruikt om de tekenreeksweergave te parseren van getallen die een bepaalde stijl hebben en die zijn opgemaakt met behulp van de conventies van een bepaalde cultuur.

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'.

Opmerkingen

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

De TryParse methode lijkt op de Parse(String, NumberStyles, IFormatProvider) methode, behalve dat deze methode geen uitzondering genereert als de conversie mislukt. Als de conversie slaagt, is de retourwaarde en true wordt de result parameter ingesteld op het resultaat van de conversie. Als de conversie mislukt, is de retourwaarde en false wordt de result parameter ingesteld op nul. Hierdoor hoeft u geen uitzonderingsafhandeling te gebruiken om te testen op een FormatException in het geval dat s deze ongeldig is en niet kan worden geparseerd.

De style parameter definieert de toegestane indeling van de parameter om de s parseringsbewerking te voltooien. Dit moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming. De volgende NumberStyles leden worden niet ondersteund:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

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

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

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

Element	Beschrijving
Ws	Optionele witruimte. Witruimte kan aan het begin van s de styleNumberStyles.AllowLeadingWhite vlag worden weergegeven. Deze kan aan het einde van s de styleNumberStyles.AllowTrailingWhite vlag worden weergegeven.
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyNegativePattern of NumberFormatInfo.CurrencyPositivePattern eigenschappen van het NumberFormatInfo object dat wordt geretourneerd door de IFormatProvider.GetFormat methode van de provider parameter. Het valutasymbool kan worden weergegeven s als style deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een optioneel teken. Het teken kan aan het begin van s de NumberStyles.AllowLeadingSignstyle vlag worden weergegeven en kan aan het einde van s de vlag worden weergegeven.styleNumberStyles.AllowTrailingSign Haakjes kunnen worden gebruikt s om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.
integral-digits	Een reeks cijfers tussen 0 en 9 die het integraal deel van het getal aangeven. Integrale cijfers kunnen afwezig zijn als er fractionele cijfers zijn.
,	Een cultuurspecifiek scheidingsteken voor duizendtallen. Het scheidingsteken voor duizendtallen van de huidige cultuur kan worden weergegeven als sstyle deze de NumberStyles.AllowThousands vlag bevat.
.	Een cultuurspecifiek decimaalteken. Het decimale puntsymbool van de huidige cultuur kan worden weergegeven s als style deze de NumberStyles.AllowDecimalPoint vlag bevat.
fractionele cijfers	Een reeks cijfers tussen 0 en 9 die het breukgedeelte van het getal aangeven. Fractionele cijfers kunnen worden weergegeven als sstyle deze de NumberStyles.AllowDecimalPoint vlag bevat.
e	Het e- of E-teken, dat aangeeft dat s een getal kan vertegenwoordigen met exponentiële notatie. De s parameter kan een getal in exponentiële notatie vertegenwoordigen als de stijl de NumberStyles.AllowExponent vlag bevat.
exponentiële cijfers	Een reeks cijfers tussen 0 en 9 die een exponent opgeven.

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

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

De provider parameter is een IFormatProvider implementatie, zoals een NumberFormatInfo of CultureInfo object. De provider parameter levert cultuurspecifieke informatie die wordt gebruikt bij parseren. Als provider een object niet NumberFormatInfonull kan worden verkregen, wordt de notatiegegevens voor de huidige cultuur gebruikt.

De conversie mislukt als de s parameter een numerieke waarde is null of niet, de provider parameter geen object oplevert NumberFormatInfo of als de style parameter geen combinatie is van bitvlaggingen uit de NumberStyles opsomming.

Normaal gesproken wordt de oorspronkelijke Double waarde geretourneerd als u de Double.TryParse methode doorgeeft een tekenreeks die wordt gemaakt door de Double.ToString methode aan te roepen. Vanwege een verlies van precisie zijn de waarden mogelijk niet gelijk. Daarnaast probeert u de tekenreeksweergave van een Double.MinValue van beide te parseren of Double.MaxValue mislukt de retour. In .NET Framework genereert het een OverflowException. In .NET Core 3.0 en latere versies wordt Double.NegativeInfinity geretourneerd als u probeert MinValue of Double.PositiveInfinity te parseren als u probeert MaxValue te parseren. In het volgende voorbeeld ziet u een afbeelding.

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.

Als s in .NET Framework buiten het gegevenstype Double valt, genereert de methode Double.TryParse(String, NumberStyles, IFormatProvider, Double) een OverflowException.

In .NET Core 3.0 en latere versies wordt er geen uitzondering gegenereerd wanneer s buiten het bereik van het gegevenstype Double valt. In de meeste gevallen berekent de Double.TryParse(String, NumberStyles, IFormatProvider, Double) methode een resultaat van Double.PositiveInfinity of Double.NegativeInfinity. Er is echter een kleine set waarden die worden beschouwd als dichter bij de maximum- of minimumwaarden dan Double positieve of negatieve oneindigheid. In die gevallen berekent de methode een resultaat van Double.MaxValue of Double.MinValue.

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

Zie ook

• ToString()
• Parsing Numerieke tekenreeksen in .NET