TimeSpan.TryParse Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Konvertiert die angegebene Zeichenfolgendarstellung eines Zeitintervalls in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich ausgeführt wurde.
Überlädt
| TryParse(String, IFormatProvider, TimeSpan) |
Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) |
Konvertiert die Spannendarstellung eines Zeitintervalls unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde. |
| TryParse(ReadOnlySpan<Char>, TimeSpan) |
Konvertiert die Spannendarstellung eines Zeitintervalls in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde. |
| TryParse(String, TimeSpan) |
Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde. |
TryParse(String, IFormatProvider, TimeSpan)
Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.
public:
static bool TryParse(System::String ^ input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);public:
static bool TryParse(System::String ^ input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result) = IParsable<TimeSpan>::TryParse;public static bool TryParse (string input, IFormatProvider formatProvider, out TimeSpan result);public static bool TryParse (string? input, IFormatProvider? formatProvider, out TimeSpan result);static member TryParse : string * IFormatProvider * TimeSpan -> boolPublic Shared Function TryParse (input As String, formatProvider As IFormatProvider, ByRef result As TimeSpan) As BooleanParameter
- input
- String
Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.
- formatProvider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- result
- TimeSpan
Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.
Gibt zurück
true, wenn input erfolgreich konvertiert wurde, andernfalls false. Dieser Vorgang gibt zurück false , wenn der input Parameter null oder Emptyist, ein ungültiges Format aufweist, ein Zeitintervall darstellt, das kleiner als TimeSpan.MinValue oder größer als TimeSpan.MaxValue ist oder mindestens eine Komponente für Tage, Stunden, Minuten oder Sekunden außerhalb des gültigen Bereichs aufweist.
Beispiele
Im folgenden Beispiel wird ein Array von CultureInfo -Objekten definiert und jedes Objekt in Aufrufen der TryParse(String, IFormatProvider, TimeSpan) -Methode verwendet, um die Elemente in einem Zeichenfolgenarray zu analysieren. Das Beispiel veranschaulicht, wie die Konventionen einer bestimmten Kultur den Formatierungsvorgang beeinflussen.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
string[] values = { "6", "6:12", "6:12:14", "6:12:14:45",
"6.12:14:45", "6:12:14:45.3448",
"6:12:14:45,3448", "6:34:14:45" };
CultureInfo[] cultures = { new CultureInfo("en-US"),
new CultureInfo("ru-RU"),
CultureInfo.InvariantCulture };
string header = String.Format("{0,-17}", "String");
foreach (CultureInfo culture in cultures)
header += culture.Equals(CultureInfo.InvariantCulture) ?
String.Format("{0,20}", "Invariant") :
String.Format("{0,20}", culture.Name);
Console.WriteLine(header);
Console.WriteLine();
foreach (string value in values)
{
Console.Write("{0,-17}", value);
foreach (CultureInfo culture in cultures)
{
TimeSpan interval = new TimeSpan();
if (TimeSpan.TryParse(value, culture, out interval))
Console.Write("{0,20}", interval.ToString("c"));
else
Console.Write("{0,20}", "Unable to Parse");
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// String en-US ru-RU Invariant
//
// 6 6.00:00:00 6.00:00:00 6.00:00:00
// 6:12 06:12:00 06:12:00 06:12:00
// 6:12:14 06:12:14 06:12:14 06:12:14
// 6:12:14:45 6.12:14:45 6.12:14:45 6.12:14:45
// 6.12:14:45 6.12:14:45 6.12:14:45 6.12:14:45
// 6:12:14:45.3448 6.12:14:45.3448000 Unable to Parse 6.12:14:45.3448000
// 6:12:14:45,3448 Unable to Parse 6.12:14:45.3448000 Unable to Parse
// 6:34:14:45 Unable to Parse Unable to Parse Unable to Parse
open System
open System.Globalization
let values =
[| "6"; "6:12"; "6:12:14"; "6:12:14:45"
"6.12:14:45"; "6:12:14:45.3448"
"6:12:14:45,3448"; "6:34:14:45" |]
let cultures =
[| CultureInfo "en-US"
CultureInfo "ru-RU"
CultureInfo.InvariantCulture |]
let mutable header = String.Format("{0,-17}", "String")
for culture in cultures do
header <-
if culture.Equals CultureInfo.InvariantCulture then
String.Format("{0,20}", "Invariant")
else
String.Format("{0,20}", culture.Name)
printfn $"{header}\n"
for value in values do
printf $"{value,-17}"
for culture in cultures do
match TimeSpan.TryParse(value, culture) with
| true, interval ->
printfn $"{interval,20:c}"
| _ ->
printfn "%20s" "Unable to Parse"
// The example displays the following output:
// String en-US ru-RU Invariant
//
// 6 6.00:00:00 6.00:00:00 6.00:00:00
// 6:12 06:12:00 06:12:00 06:12:00
// 6:12:14 06:12:14 06:12:14 06:12:14
// 6:12:14:45 6.12:14:45 6.12:14:45 6.12:14:45
// 6.12:14:45 6.12:14:45 6.12:14:45 6.12:14:45
// 6:12:14:45.3448 6.12:14:45.3448000 Unable to Parse 6.12:14:45.3448000
// 6:12:14:45,3448 Unable to Parse 6.12:14:45.3448000 Unable to Parse
// 6:34:14:45 Unable to Parse Unable to Parse Unable to Parse
Imports System.Globalization
Module Example
Public Sub Main()
Dim values() As String = { "6", "6:12", "6:12:14", "6:12:14:45",
"6.12:14:45", "6:12:14:45.3448",
"6:12:14:45,3448", "6:34:14:45" }
Dim cultures() As CultureInfo = { New CultureInfo("en-US"),
New CultureInfo("ru-RU"),
CultureInfo.InvariantCulture }
Dim header As String = String.Format("{0,-17}", "String")
For Each culture As CultureInfo In cultures
header += If(culture.Equals(CultureInfo.InvariantCulture),
String.Format("{0,20}", "Invariant"),
String.Format("{0,20}", culture.Name))
Next
Console.WriteLine(header)
Console.WriteLine()
For Each value As String In values
Console.Write("{0,-17}", value)
For Each culture As CultureInfo In cultures
Dim interval As New TimeSpan()
If TimeSpan.TryParse(value, culture, interval) Then
Console.Write("{0,20}", interval.ToString("c"))
Else
Console.Write("{0,20}", "Unable to Parse")
End If
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' String en-US ru-RU Invariant
'
' 6 6.00:00:00 6.00:00:00 6.00:00:00
' 6:12 06:12:00 06:12:00 06:12:00
' 6:12:14 06:12:14 06:12:14 06:12:14
' 6:12:14:45 6.12:14:45 6.12:14:45 6.12:14:45
' 6.12:14:45 6.12:14:45 6.12:14:45 6.12:14:45
' 6:12:14:45.3448 6.12:14:45.3448000 Unable to Parse 6.12:14:45.3448000
' 6:12:14:45,3448 Unable to Parse 6.12:14:45.3448000 Unable to Parse
' 6:34:14:45 Unable to Parse Unable to Parse Unable to Parse
Hinweise
Die TryParse(String, IFormatProvider, TimeSpan) -Methode ähnelt der -Methode, mit der Parse(String, IFormatProvider) Ausnahme, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt.
Der input Parameter enthält eine Zeitintervallspezifikation im Format:
[ws] [-] { d | d. hh:mm[:ss[.ff]] | hh:mm[:ss[.ff]] }[ws]
Elemente in eckigen Klammern ([ und ]) sind optional. Eine Auswahl aus der Liste der Alternativen, die in geschweifte Klammern ({ und }) eingeschlossen und durch vertikale Balken (|) getrennt sind, ist erforderlich. In der folgenden Tabelle wird jedes Element beschrieben.
| Element | BESCHREIBUNG |
|---|---|
| ws | Optionaler Leerraum. |
| - | Ein optionales Minuszeichen, das ein negatives TimeSpanangibt. |
| d | Tage zwischen 0 und 10675199. |
| . | Ein kulturabhängiges Symbol, das Tage von Stunden trennt. Das invariante Format verwendet ein Punktzeichen ("."). |
| hh | Stunden im Bereich von 0 bis 23. |
| : | Das kulturabhängige Zeittrennzeichensymbol. Für das invariante Format wird ein Doppelpunkt (":") verwendet. |
| mm | Minuten zwischen 0 und 59. |
| ss | Optionale Sekunden im Bereich von 0 bis 59. |
| . | Ein kulturabhängiges Symbol, das Sekunden von Sekundenbruchteilen trennt. Das invariante Format verwendet ein Punktzeichen ("."). |
| Ff | Optionale Sekundenbruchteile, bestehend aus einer bis sieben Dezimalstellen. |
Die Komponenten von input müssen zusammen ein Zeitintervall angeben, das größer oder gleich TimeSpan.MinValue und kleiner oder gleich TimeSpan.MaxValueist.
Die TryParse(String, IFormatProvider, TimeSpan) -Methode versucht, die einzelnen kulturspezifischen Formate für die durch formatProviderangegebene Kultur zu analysiereninput.
Der formatProvider Parameter ist eine IFormatProvider Implementierung, die kulturspezifische Informationen zum Format der zurückgegebenen Zeichenfolge bereitstellt. Der formatProvider Parameter kann einer der folgenden Sein:
Ein CultureInfo -Objekt, das die Kultur darstellt, deren Formatierungskonventionen in der zurückgegebenen Zeichenfolge widergespiegelt werden sollen. Das DateTimeFormatInfo von der CultureInfo.DateTimeFormat -Eigenschaft zurückgegebene Objekt definiert die Formatierung der zurückgegebenen Zeichenfolge.
Ein DateTimeFormatInfo -Objekt, das die Formatierung der zurückgegebenen Zeichenfolge definiert.
Ein benutzerdefiniertes Objekt, das die IFormatProvider -Schnittstelle implementiert. Die - IFormatProvider.GetFormat Methode gibt ein DateTimeFormatInfo -Objekt zurück, das Formatierungsinformationen bereitstellt.
Wenn formatProvider ist null, wird das DateTimeFormatInfo Objekt verwendet, das der aktuellen Kultur zugeordnet ist.
Hinweise für Anrufer
In einigen Fällen, wenn eine Zeitintervallkomponente in der zu analysierenden Zeichenfolge mehr als sieben Ziffern enthält, können Analysevorgänge, die erfolgreich sind und in den .NET Framework 3.5 und früheren Versionen zurückgegeben true werden, fehlschlagen und in the.NET Framework 4 und höheren Versionen zurückgegeben werdenfalse. Das folgende Beispiel veranschaulicht dieses Szenario:
string value = "000000006";
TimeSpan interval;
if (TimeSpan.TryParse(value, out interval))
Console.WriteLine("{0} --> {1}", value, interval);
else
Console.WriteLine("Unable to parse '{0}'", value);
// Output from .NET Framework 3.5 and earlier versions:
// 000000006 --> 6.00:00:00
// Output from .NET Framework 4:
// Unable to parse //000000006//
let value = "000000006"
match TimeSpan.TryParse value with
| true, interval ->
printfn $"{value} --> {interval}"
| _ ->
printfn $"Unable to parse '{value}'"
// Output from .NET Framework 3.5 and earlier versions:
// 000000006 --> 6.00:00:00
// Output from .NET Framework 4:
// Unable to parse //000000006//
Dim value As String = "000000006"
Dim interval As TimeSpan
If TimeSpan.TryParse(value, interval) Then
Console.WriteLine("{0} --> {1}", value, interval)
Else
Console.WriteLine("Unable to parse '{0}'", value)
End If
' Output from .NET Framework 3.5 and earlier versions:
' 000000006 --> 6.00:00:00
' Output from .NET Framework 4:
' Unable to parse '000000006'
Gilt für:
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
Konvertiert die Spannendarstellung eines Zeitintervalls unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.
public:
static bool TryParse(ReadOnlySpan<char> input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result);public:
static bool TryParse(ReadOnlySpan<char> input, IFormatProvider ^ formatProvider, [Runtime::InteropServices::Out] TimeSpan % result) = ISpanParsable<TimeSpan>::TryParse;public static bool TryParse (ReadOnlySpan<char> input, IFormatProvider? formatProvider, out TimeSpan result);public static bool TryParse (ReadOnlySpan<char> input, IFormatProvider formatProvider, out TimeSpan result);static member TryParse : ReadOnlySpan<char> * IFormatProvider * TimeSpan -> boolPublic Shared Function TryParse (input As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, ByRef result As TimeSpan) As BooleanParameter
- input
- ReadOnlySpan<Char>
Eine Spanne mit den Zeichen, die das zu konvertierende Zeitintervall darstellen.
- formatProvider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen bereitstellt.
- result
- TimeSpan
Diese Methode gibt entweder ein Objekt zurück, das das durch input angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.
Gibt zurück
true, wenn input erfolgreich konvertiert wurde, andernfalls false. Dieser Vorgang gibt zurück false , wenn der input Parameter null oder Emptyist, ein ungültiges Format aufweist, ein Zeitintervall darstellt, das kleiner als TimeSpan.MinValue oder größer als TimeSpan.MaxValue ist oder mindestens eine Komponente für Tage, Stunden, Minuten oder Sekunden außerhalb des gültigen Bereichs aufweist.
Gilt für:
TryParse(ReadOnlySpan<Char>, TimeSpan)
Konvertiert die Spannendarstellung eines Zeitintervalls in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.
public:
static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] TimeSpan % result);public static bool TryParse (ReadOnlySpan<char> s, out TimeSpan result);static member TryParse : ReadOnlySpan<char> * TimeSpan -> boolPublic Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As TimeSpan) As BooleanParameter
- s
- ReadOnlySpan<Char>
Eine Spanne mit den Zeichen, die das zu konvertierende Zeitintervall darstellen.
- result
- TimeSpan
Diese Methode gibt entweder ein Objekt zurück, das das durch s angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.
Gibt zurück
true, wenn s erfolgreich konvertiert wurde, andernfalls false. Dieser Vorgang gibt zurück false , wenn der s Parameter null oder Emptyist, ein ungültiges Format aufweist, ein Zeitintervall darstellt, das kleiner als TimeSpan.MinValue oder größer als TimeSpan.MaxValue ist oder mindestens eine Komponente für Tage, Stunden, Minuten oder Sekunden außerhalb des gültigen Bereichs aufweist.
Gilt für:
TryParse(String, TimeSpan)
Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.
public:
static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] TimeSpan % result);public static bool TryParse (string s, out TimeSpan result);public static bool TryParse (string? s, out TimeSpan result);static member TryParse : string * TimeSpan -> boolPublic Shared Function TryParse (s As String, ByRef result As TimeSpan) As BooleanParameter
- s
- String
Eine Zeichenfolge, die das zu konvertierende Zeitintervall angibt.
- result
- TimeSpan
Diese Methode gibt entweder ein Objekt zurück, das das durch s angegebene Zeitintervall darstellt, oder Zero, wenn die Konvertierung nicht ausgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben.
Gibt zurück
true, wenn s erfolgreich konvertiert wurde, andernfalls false. Dieser Vorgang gibt zurück false , wenn der s Parameter null oder Emptyist, ein ungültiges Format aufweist, ein Zeitintervall darstellt, das kleiner als TimeSpan.MinValue oder größer als TimeSpan.MaxValue ist oder mindestens eine Komponente für Tage, Stunden, Minuten oder Sekunden außerhalb des gültigen Bereichs aufweist.
Beispiele
Im folgenden Beispiel wird die TryParse -Methode verwendet, um Objekte aus gültigen TimeSpan Zeichenfolgen zu erstellen TimeSpan und anzugeben, wann der Analysevorgang fehlgeschlagen ist, da die Zeitspannenzeichenfolge ungültig ist.
using System;
public class TryParse
{
private static void ParseTimeSpan(string intervalStr)
{
// Write the first part of the output line.
Console.Write( "{0,20} ", intervalStr );
// Parse the parameter, and then convert it back to a string.
TimeSpan intervalVal;
if (TimeSpan.TryParse(intervalStr, out intervalVal))
{
string intervalToStr = intervalVal.ToString();
// Pad the end of the TimeSpan string with spaces if it
// does not contain milliseconds.
int pIndex = intervalToStr.IndexOf(':');
pIndex = intervalToStr.IndexOf('.', pIndex);
if (pIndex < 0)
intervalToStr += " ";
Console.WriteLine("{0,21}", intervalToStr);
// Handle failure of TryParse method.
}
else
{
Console.WriteLine("Parse operation failed.");
}
}
public static void Main()
{
Console.WriteLine( "{0,20} {1,21}",
"String to Parse", "TimeSpan" );
Console.WriteLine( "{0,20} {1,21}",
"---------------", "---------------------" );
ParseTimeSpan("0");
ParseTimeSpan("14");
ParseTimeSpan("1:2:3");
ParseTimeSpan("0:0:0.250");
ParseTimeSpan("10.20:30:40.50");
ParseTimeSpan("99.23:59:59.9999999");
ParseTimeSpan("0023:0059:0059.0099");
ParseTimeSpan("23:0:0");
ParseTimeSpan("24:0:0");
ParseTimeSpan("0:59:0");
ParseTimeSpan("0:60:0");
ParseTimeSpan("0:0:59");
ParseTimeSpan("0:0:60");
ParseTimeSpan("10:");
ParseTimeSpan("10:0");
ParseTimeSpan(":10");
ParseTimeSpan("0:10");
ParseTimeSpan("10:20:");
ParseTimeSpan("10:20:0");
ParseTimeSpan(".123");
ParseTimeSpan("0.12:00");
ParseTimeSpan("10.");
ParseTimeSpan("10.12");
ParseTimeSpan("10.12:00");
}
}
// String to Parse TimeSpan
// --------------- ---------------------
// 0 00:00:00
// 14 14.00:00:00
// 1:2:3 01:02:03
// 0:0:0.250 00:00:00.2500000
// 10.20:30:40.50 10.20:30:40.5000000
// 99.23:59:59.9999999 99.23:59:59.9999999
// 0023:0059:0059.0099 23:59:59.0099000
// 23:0:0 23:00:00
// 24:0:0 Parse operation failed.
// 0:59:0 00:59:00
// 0:60:0 Parse operation failed.
// 0:0:59 00:00:59
// 0:0:60 Parse operation failed.
// 10: Parse operation failed.
// 10:0 10:00:00
// :10 Parse operation failed.
// 0:10 00:10:00
// 10:20: Parse operation failed.
// 10:20:0 10:20:00
// .123 Parse operation failed.
// 0.12:00 12:00:00
// 10. Parse operation failed.
// 10.12 Parse operation failed.
// 10.12:00 10.12:00:00
open System
let parseTimeSpan intervalStr =
// Write the first part of the output line.
printf $"%20s{intervalStr} "
// Parse the parameter, and then convert it back to a string.
match TimeSpan.TryParse intervalStr with
| true, intervalVal ->
let intervalToStr = string intervalVal
// Pad the end of the TimeSpan string with spaces if it
// does not contain milliseconds.
let pIndex = intervalToStr.IndexOf ':'
let pIndex = intervalToStr.IndexOf('.', pIndex)
let intervalToStr =
if pIndex < 0 then
intervalToStr + " "
else intervalStr
printfn $"{intervalToStr,21}"
// Handle failure of TryParse method.
| _ ->
printfn "Parse operation failed."
printfn "%20s %21s" "String to Parse" "TimeSpan"
printfn "%20s %21s" "---------------" "---------------------"
parseTimeSpan "0"
parseTimeSpan "14"
parseTimeSpan "1:2:3"
parseTimeSpan "0:0:0.250"
parseTimeSpan "10.20:30:40.50"
parseTimeSpan "99.23:59:59.9999999"
parseTimeSpan "0023:0059:0059.0099"
parseTimeSpan "23:0:0"
parseTimeSpan "24:0:0"
parseTimeSpan "0:59:0"
parseTimeSpan "0:60:0"
parseTimeSpan "0:0:59"
parseTimeSpan "0:0:60"
parseTimeSpan "10:"
parseTimeSpan "10:0"
parseTimeSpan ":10"
parseTimeSpan "0:10"
parseTimeSpan "10:20:"
parseTimeSpan "10:20:0"
parseTimeSpan ".123"
parseTimeSpan "0.12:00"
parseTimeSpan "10."
parseTimeSpan "10.12"
parseTimeSpan "10.12:00"
// String to Parse TimeSpan
// --------------- ---------------------
// 0 00:00:00
// 14 14.00:00:00
// 1:2:3 01:02:03
// 0:0:0.250 00:00:00.2500000
// 10.20:30:40.50 10.20:30:40.5000000
// 99.23:59:59.9999999 99.23:59:59.9999999
// 0023:0059:0059.0099 23:59:59.0099000
// 23:0:0 23:00:00
// 24:0:0 Parse operation failed.
// 0:59:0 00:59:00
// 0:60:0 Parse operation failed.
// 0:0:59 00:00:59
// 0:0:60 Parse operation failed.
// 10: Parse operation failed.
// 10:0 10:00:00
// :10 Parse operation failed.
// 0:10 00:10:00
// 10:20: Parse operation failed.
// 10:20:0 10:20:00
// .123 Parse operation failed.
// 0.12:00 12:00:00
// 10. Parse operation failed.
// 10.12 Parse operation failed.
// 10.12:00 10.12:00:00
Module TryParse
Sub ParseTimeSpan( intervalStr As String )
' Write the first part of the output line.
Console.Write( "{0,20} ", intervalStr )
' Parse the parameter, and then convert it back to a string.
Dim intervalVal As TimeSpan
If TimeSpan.TryParse( intervalStr, intervalVal ) Then
Dim intervalToStr As String = intervalVal.ToString( )
' Pad the end of the TimeSpan string with spaces if it
' does not contain milliseconds.
Dim pIndex As Integer = intervalToStr.IndexOf( ":"c )
pIndex = intervalToStr.IndexOf( "."c, pIndex )
If pIndex < 0 Then intervalToStr &= " "
Console.WriteLine( "{0,21}", intervalToStr )
' Handle failure of TryParse method.
Else
Console.WriteLine("Parse operation failed.")
End If
End Sub
Public Sub Main( )
Console.WriteLine( "{0,20} {1,21}", _
"String to Parse", "TimeSpan" )
Console.WriteLine( "{0,20} {1,21}", _
"---------------", "---------------------" )
ParseTimeSpan("0")
ParseTimeSpan("14")
ParseTimeSpan("1:2:3")
ParseTimeSpan("0:0:0.250")
ParseTimeSpan("10.20:30:40.50")
ParseTimeSpan("99.23:59:59.9999999")
ParseTimeSpan("0023:0059:0059.0099")
ParseTimeSpan("23:0:0")
ParseTimeSpan("24:0:0")
ParseTimespan("0:59:0")
ParseTimeSpan("0:60:0")
ParseTimespan("0:0:59")
ParseTimeSpan("0:0:60")
ParseTimeSpan("10:")
ParsetimeSpan("10:0")
ParseTimeSpan(":10")
ParseTimeSpan("0:10")
ParseTimeSpan("10:20:")
ParseTimeSpan("10:20:0")
ParseTimeSpan(".123")
ParseTimeSpan("0.12:00")
ParseTimeSpan("10.")
ParseTimeSpan("10.12")
ParseTimeSpan("10.12:00")
End Sub
End Module
' This example generates the following output:
' String to Parse TimeSpan
' --------------- ---------------------
' 0 00:00:00
' 14 14.00:00:00
' 1:2:3 01:02:03
' 0:0:0.250 00:00:00.2500000
' 10.20:30:40.50 10.20:30:40.5000000
' 99.23:59:59.9999999 99.23:59:59.9999999
' 0023:0059:0059.0099 23:59:59.0099000
' 23:0:0 23:00:00
' 24:0:0 Parse operation failed.
' 0:59:0 00:59:00
' 0:60:0 Parse operation failed.
' 0:0:59 00:00:59
' 0:0:60 Parse operation failed.
' 10: Parse operation failed.
' 10:0 10:00:00
' :10 Parse operation failed.
' 0:10 00:10:00
' 10:20: Parse operation failed.
' 10:20:0 10:20:00
' .123 Parse operation failed.
' 0.12:00 12:00:00
' 10. Parse operation failed.
' 10.12 Parse operation failed.
' 10.12:00 10.12:00:00
Hinweise
Die TryParse -Methode ähnelt der -Methode, mit der TimeSpan.Parse(String) Ausnahme, dass sie keine Ausnahme auslöst, wenn die Konvertierung fehlschlägt.
Der s Parameter enthält eine Zeitintervallspezifikation im Format:
[ws] [-] { d | d. hh:mm[:ss[.ff]] | hh:mm[:ss[.ff]] }[ws]
Elemente in eckigen Klammern ([ und ]) sind optional. Eine Auswahl aus der Liste der Alternativen, die in geschweifte Klammern ({ und }) eingeschlossen und durch vertikale Balken (|) getrennt sind, ist erforderlich. In der folgenden Tabelle wird jedes Element beschrieben.
| Element | BESCHREIBUNG |
|---|---|
| ws | Optionaler Leerraum. |
| - | Ein optionales Minuszeichen, das ein negatives TimeSpanangibt. |
| d | Tage zwischen 0 und 10675199. |
| . | Ein kulturabhängiges Symbol, das Tage von Stunden trennt. Das invariante Format verwendet ein Punktzeichen ("."). |
| hh | Stunden im Bereich von 0 bis 23. |
| : | Das kulturabhängige Zeittrennzeichensymbol. Für das invariante Format wird ein Doppelpunkt (":") verwendet. |
| mm | Minuten zwischen 0 und 59. |
| ss | Optionale Sekunden im Bereich von 0 bis 59. |
| . | Ein kulturabhängiges Symbol, das Sekunden von Sekundenbruchteilen trennt. Das invariante Format verwendet ein Punktzeichen ("."). |
| Ff | Optionale Sekundenbruchteile, bestehend aus einer bis sieben Dezimalstellen. |
Die Komponenten von s müssen zusammen ein Zeitintervall angeben, das größer oder gleich TimeSpan.MinValue und kleiner oder gleich TimeSpan.MaxValueist.
Die Parse(String) -Methode versucht, die einzelnen kulturspezifischen Formate für die aktuelle Kultur zu analysieren s .
Hinweise für Anrufer
In einigen Fällen, wenn eine Zeitintervallkomponente in der zu analysierenden Zeichenfolge mehr als sieben Ziffern enthält, können Analysevorgänge, die in der .NET Framework 3.5 und früheren Versionen erfolgreich sind, fehlschlagen und eine OverflowException in der .NET Framework 4 und höher auslösen. Dies wird im folgenden Beispiel veranschaulicht.
string value = "000000006";
TimeSpan interval;
if (TimeSpan.TryParse(value, out interval))
Console.WriteLine("{0} --> {1}", value, interval);
else
Console.WriteLine("Unable to parse '{0}'", value);
// Output from .NET Framework 3.5 and earlier versions:
// 000000006 --> 6.00:00:00
// Output from .NET Framework 4:
// Unable to parse //000000006//
let value = "000000006"
match TimeSpan.TryParse value with
| true, interval ->
printfn $"{value} --> {interval}"
| _ ->
printfn $"Unable to parse '{value}'"
// Output from .NET Framework 3.5 and earlier versions:
// 000000006 --> 6.00:00:00
// Output from .NET Framework 4:
// Unable to parse //000000006//
Dim value As String = "000000006"
Dim interval As TimeSpan
If TimeSpan.TryParse(value, interval) Then
Console.WriteLine("{0} --> {1}", value, interval)
Else
Console.WriteLine("Unable to parse '{0}'", value)
End If
' Output from .NET Framework 3.5 and earlier versions:
' 000000006 --> 6.00:00:00
' Output from .NET Framework 4:
' Unable to parse '000000006'
Gilt für:
Feedback
Feedback senden und anzeigen für