Double.TryParse Methode

Source:

Double.cs

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true , wenn s erfolgreich analysiert wurde, falseandernfalls .

Source:

Double.cs

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true, wenn s erfolgreich konvertiert wurde, andernfalls false.

Hinweise

In .NET Core 3.0 und höher werden Werte, die für die Darstellung zu groß sind, entsprechend der IEEE 754-Spezifikation auf PositiveInfinity oder NegativeInfinity gerundet. In früheren Versionen, einschließlich .NET Framework, führte die Analyse eines Werts, der für die Darstellung zu groß war, zu Einem Fehler.

Source:

Double.cs

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true, wenn s erfolgreich konvertiert wurde, andernfalls false.

Beispiele

Im folgenden Beispiel wird die TryParse(String, Double) -Methode verwendet, um die Zeichenfolgendarstellungen numerischer Werte in Werte zu Double konvertieren. Es wird davon ausgegangen, dass en-US die aktuelle Kultur ist.

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

Hinweise

In .NET Core 3.0 und höher werden Werte, die für die Darstellung zu groß sind, entsprechend der IEEE 754-Spezifikation auf PositiveInfinity oder NegativeInfinity gerundet. In früheren Versionen, einschließlich .NET Framework, führte die Analyse eines Werts, der für die Darstellung zu groß war, zu Einem Fehler.

Diese Überladung unterscheidet sich von der Double.Parse(String) -Methode, indem sie einen booleschen Wert zurückgibt, der angibt, ob der Analysevorgang erfolgreich war, anstatt den analysierten numerischen Wert zurückzugeben. Es entfällt die Notwendigkeit, die Ausnahmebehandlung zu verwenden, um im Fall eines FormatException zu testen, das s ungültig ist und nicht erfolgreich analysiert werden kann.

Der s Parameter kann die aktuelle Kultur NumberFormatInfo.PositiveInfinitySymbolenthalten, NumberFormatInfo.NegativeInfinitySymbol, NumberFormatInfo.NaNSymbol (beim Zeichenfolgenvergleich wird die Groß-/Kleinschreibung beachtet) oder eine Zeichenfolge im Format:

[ws] [sign] [ganzzahlige Ziffern,]ganzzahlige Ziffern[.[ fractional-digits]][e[sign]exponential-digits][ws]

Elemente in eckigen Klammern sind optional. In der folgenden Tabelle wird jedes Element beschrieben.

Weitere Informationen zu numerischen Formaten finden Sie unter Formatierungstypen.

Der s Parameter wird mithilfe einer Kombination aus den NumberStyles.Float Flags und NumberStyles.AllowThousands interpretiert. Dies bedeutet, dass Leerzeichen und Tausendertrennzeichen zulässig sind, Währungssymbole jedoch nicht. Verwenden Sie die -Methodenüberladung, um explizit die Elemente (z. B. Währungssymbole, Tausendertrennzeichen und Leerzeichen) zu definieren, die Double.TryParse(String, NumberStyles, IFormatProvider, Double) in svorhanden sein können.

Der s Parameter wird mithilfe der Formatierungsinformationen in einem NumberFormatInfo Objekt analysiert, das für die aktuelle Systemkultur initialisiert wird. Weitere Informationen finden Sie unter NumberFormatInfo.CurrentInfo. Um eine Zeichenfolge mithilfe der Formatierungsinformationen einer anderen angegebenen Kultur zu analysieren, verwenden Sie die Double.TryParse(String, NumberStyles, IFormatProvider, Double) Methodenüberladung.

Wenn Sie der Double.TryParse Methode normalerweise eine Zeichenfolge übergeben, die durch Aufrufen der Double.ToString -Methode erstellt wird, wird der ursprüngliche Double Wert zurückgegeben. Aufgrund eines Genauigkeitsverlusts sind die Werte jedoch möglicherweise nicht gleich. Darüber hinaus schlägt der Versuch, die Zeichenfolgendarstellung von oder Double.MinValueDouble.MaxValue zu analysieren, einen Roundtrip fehl. Unter .NET Framework und .NET Core 2.2 und früheren Versionen wird eine OverflowExceptionausgelöst. Unter .NET Core 3.0 und höheren Versionen wird Double.NegativeInfinity zurückgegeben, wenn Sie versuchen, zu analysieren MinValue oder Double.PositiveInfinity zu analysieren MaxValue. Dies wird im folgenden Beispiel veranschaulicht.

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.

Wenn sich .NET Framework und .NET Core 2.2 und früheren Versionen s außerhalb des Bereichs des Double Datentyps befindet, löst die TryParse(String, Double) -Methode eine ausOverflowException.

Unter .NET Core 3.0 und höheren Versionen wird keine Ausnahme ausgelöst, wenn s sich außerhalb des Bereichs des Datentyps Double befindet. In den meisten Fällen berechnet die TryParse(String, Double) -Methode ein Ergebnis von Double.PositiveInfinity oder Double.NegativeInfinity. Es gibt jedoch eine kleine Gruppe von Werten, die als näher an den Maximal- oder Minimalwerten von Double als an positiver oder negativer Unendlichkeit liegen. In diesen Fällen berechnet die -Methode ein Ergebnis von Double.MaxValue oder Double.MinValue.

Wenn im s Parameter während eines Analysevorgangs ein Trennzeichen gefunden wird und die Dezimal- und Gruppentrennzeichen identisch sind, wird beim Analysevorgang davon ausgegangen, dass das Trennzeichen ein Dezimaltrennzeichen und kein Gruppentrennzeichen ist. Weitere Informationen zu Trennzeichen finden Sie unter CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatorund NumberGroupSeparator.

Weitere Informationen

• Parse(String)
• ToString()
• Analysieren numerischer Zeichenfolgen in .NET
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (C#)
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (Visual Basic)

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true , wenn utf8Text erfolgreich analysiert wurde, falseandernfalls .

Source:

Double.cs

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true , wenn s erfolgreich analysiert wurde, falseandernfalls .

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true , wenn utf8Text erfolgreich analysiert wurde, falseandernfalls .

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true, wenn utf8Text erfolgreich konvertiert wurde, andernfalls false.

Source:

Double.cs

Source:

Double.cs

Source:

Double.cs

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, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;

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

Parameter

Gibt zurück

true, wenn s erfolgreich konvertiert wurde, andernfalls false.

Hinweise

In .NET Core 3.0 und höher werden Werte, die für die Darstellung zu groß sind, entsprechend der IEEE 754-Spezifikation auf PositiveInfinity oder NegativeInfinity gerundet. In früheren Versionen, einschließlich .NET Framework, führte die Analyse eines Werts, der für die Darstellung zu groß war, zu Einem Fehler.

Source:

Double.cs

Source:

Double.cs

Source:

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

Parameter

Gibt zurück

true, wenn s erfolgreich konvertiert wurde, andernfalls false.

Ausnahmen

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung der Double.TryParse(String, NumberStyles, IFormatProvider, Double) -Methode zum Analysieren der Zeichenfolgendarstellung von Zahlen, die einen bestimmten Stil aufweisen und mit den Konventionen einer bestimmten Kultur formatiert sind.

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

Hinweise

In .NET Core 3.0 und höher werden Werte, die für die Darstellung zu groß sind, entsprechend der IEEE 754-Spezifikation auf PositiveInfinity oder NegativeInfinity gerundet. In früheren Versionen, einschließlich .NET Framework, führte die Analyse eines Werts, der für die Darstellung zu groß war, zu Einem Fehler.

Die TryParse -Methode ähnelt der Parse(String, NumberStyles, IFormatProvider) -Methode, mit der Ausnahme, dass diese Methode keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt. Wenn die Konvertierung erfolgreich ist, ist true der Rückgabewert, und der result Parameter wird auf das Ergebnis der Konvertierung festgelegt. Wenn die Konvertierung fehlschlägt, ist false der Rückgabewert, und der result Parameter wird auf 0 festgelegt. Dadurch entfällt die Notwendigkeit, die Ausnahmebehandlung zu verwenden, um im Fall eines FormatException zu testen, das s ungültig ist und nicht erfolgreich analysiert werden kann.

Der style Parameter definiert das zulässige Format des s Parameters, damit der Analysevorgang erfolgreich ist. Es muss sich um eine Kombination von Bitflags aus der NumberStyles Enumeration handeln. Die folgenden NumberStyles Member werden nicht unterstützt:

• NumberStyles.AllowHexSpecifier

• NumberStyles.HexNumber

Der s Parameter kann , NumberFormatInfo.NegativeInfinitySymboloder NumberFormatInfo.NaNSymbol für die kultur enthaltenNumberFormatInfo.PositiveInfinitySymbol, die durch angegeben wirdprovider. Außerdem kann der s Parameter abhängig vom Wert von styledie folgenden Elemente enthalten:

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

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle wird jedes Element beschrieben.

Eine Zeichenfolge nur mit Ziffern (die der NumberStyles.None Formatvorlage entspricht) analysiert immer erfolgreich, wenn sie sich im Bereich des Double Typs befindet. Die verbleibenden System.Globalization.NumberStyles Member steuern Elemente, die möglicherweise in der Eingabezeichenfolge vorhanden sein müssen, aber nicht erforderlich sind. In der folgenden Tabelle wird angegeben, wie sich einzelne NumberStyles Flags auf die Elemente auswirken, die in svorhanden sein können.

Der provider Parameter ist eine IFormatProvider Implementierung, z. B. ein - oder CultureInfo -NumberFormatInfoObjekt. Der provider Parameter stellt kulturspezifische Informationen bereit, die bei der Analyse verwendet werden. Wenn provider ist null oder ein NumberFormatInfo Objekt nicht abgerufen werden kann, werden die Formatinformationen für die aktuelle Kultur verwendet.

Die Konvertierung schlägt fehl, wenn der s Parameter ein numerischer Wert ist null oder nicht, der provider Parameter kein Objekt ergibt NumberFormatInfo oder der style Parameter keine Kombination von Bitflags aus der NumberStyles Enumeration ist.

Wenn Sie der Double.TryParse Methode normalerweise eine Zeichenfolge übergeben, die durch Aufrufen der Double.ToString -Methode erstellt wird, wird der ursprüngliche Double Wert zurückgegeben. Aufgrund eines Genauigkeitsverlusts sind die Werte jedoch möglicherweise nicht gleich. Darüber hinaus schlägt der Versuch, die Zeichenfolgendarstellung von oder Double.MinValueDouble.MaxValue zu analysieren, einen Roundtrip fehl. Unter .NET Framework und .NET Core 2.2 und früheren Versionen wird eine OverflowExceptionausgelöst. Unter .NET Core 3.0 und höheren Versionen wird Double.NegativeInfinity zurückgegeben, wenn Sie versuchen, zu analysieren MinValue oder Double.PositiveInfinity zu analysieren MaxValue. Dies wird im folgenden Beispiel veranschaulicht.

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.

Wenn sich .NET Framework und .NET Core 2.2 und früheren Versionen s außerhalb des Bereichs des Double Datentyps befindet, löst die Double.TryParse(String, NumberStyles, IFormatProvider, Double) -Methode eine ausOverflowException.

Unter .NET Core 3.0 und höheren Versionen wird keine Ausnahme ausgelöst, wenn s sich außerhalb des Bereichs des Datentyps Double befindet. In den meisten Fällen berechnet die Double.TryParse(String, NumberStyles, IFormatProvider, Double) -Methode ein Ergebnis von Double.PositiveInfinity oder Double.NegativeInfinity. Es gibt jedoch eine kleine Gruppe von Werten, die als näher an den Maximal- oder Minimalwerten von Double als an positiver oder negativer Unendlichkeit liegen. In diesen Fällen berechnet die -Methode ein Ergebnis von Double.MaxValue oder Double.MinValue.

Wenn im s Parameter während eines Analysevorgangs ein Trennzeichen auftritt und die entsprechenden Währungs- oder Zahlendezimal- und Gruppentrennzeichen identisch sind, wird beim Analysevorgang davon ausgegangen, dass das Trennzeichen ein Dezimaltrennzeichen und kein Gruppentrennzeichen ist. Weitere Informationen zu Trennzeichen finden Sie unter CurrencyDecimalSeparator, NumberDecimalSeparator, CurrencyGroupSeparatorund NumberGroupSeparator.

Weitere Informationen

• ToString()
• Analysieren numerischer Zeichenfolgen in .NET