TimeSpan Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

TimeSpan.cs

Stellt ein Zeitintervall dar.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
    interface IUtf8SpanFormattable

Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan), IUtf8SpanFormattable

Vererbung

Object

ValueType

TimeSpan

Implementiert

IComparable IComparable<TimeSpan> IEquatable<TimeSpan> IFormattable ISpanFormattable IParsable<TimeSpan> IParsable<TSelf> ISpanParsable<TimeSpan> IUtf8SpanFormattable

Beispiele

Im folgenden Beispiel wird ein TimeSpan-Objekt instanziiert, das den Unterschied zwischen zwei Datumsangaben darstellt. Anschließend werden die Eigenschaften des TimeSpan Objekts angezeigt.

// Define two dates.
DateTime date1 = new DateTime(2010, 1, 1, 8, 0, 15);
DateTime date2 = new DateTime(2010, 8, 18, 13, 30, 30);

// Calculate the interval between the two dates.
TimeSpan interval = date2 - date1;
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString());

// Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays);
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours);
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks);

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000

// Define two dates.
let date1 = DateTime(2010, 1, 1, 8, 0, 15)
let date2 = DateTime(2010, 8, 18, 13, 30, 30)

// Calculate the interval between the two dates.
let interval = date2 - date1
printfn $"{date2} - {date1} = {interval}"

// Display individual properties of the resulting TimeSpan object.
printfn $"""   {"Value of Days Component:",-35} {interval.Days,20}""" 
printfn $"""   {"Total Number of Days:",-35} {interval.TotalDays,20}""" 
printfn $"""   {"Value of Hours Component:",-35} {interval.Hours,20}""" 
printfn $"""   {"Total Number of Hours:",-35} {interval.TotalHours,20}""" 
printfn $"""   {"Value of Minutes Component:",-35} {interval.Minutes,20}""" 
printfn $"""   {"Total Number of Minutes:",-35} {interval.TotalMinutes,20}""" 
printfn $"""   {"Value of Seconds Component:",-35} {interval.Seconds,20:N0}""" 
printfn $"""   {"Total Number of Seconds:",-35} {interval.TotalSeconds,20:N0}""" 
printfn $"""   {"Value of Milliseconds Component:",-35} {interval.Milliseconds,20:N0}""" 
printfn $"""   {"Total Number of Milliseconds:",-35} {interval.TotalMilliseconds,20:N0}""" 
printfn $"""   {"Ticks:",-35} {interval.Ticks,20:N0}""" 

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000

' Define two dates.
Dim date1 As Date = #1/1/2010 8:00:15AM#
Dim date2 As Date = #8/18/2010 1:30:30PM#
' Calculate the interval between the two dates.
Dim interval As TimeSpan = date2 - date1
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString())
' Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays)
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours)
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks)
' The example displays the following output:
'       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
'          Value of Days Component:                             229
'          Total Number of Days:                   229.229340277778
'          Value of Hours Component:                              5
'          Total Number of Hours:                  5501.50416666667
'          Value of Minutes Component:                           30
'          Total Number of Minutes:                       330090.25
'          Value of Seconds Component:                           15
'          Total Number of Seconds:                      19,805,415
'          Value of Milliseconds Component:                       0
'          Total Number of Milliseconds:             19,805,415,000
'          Ticks:                               198,054,150,000,000

# Define two dates.
$Date2 = Get-Date -Date '2010/8/18' -Hour 13 -Minute 30 -Second 30
$Date1 = Get-Date -Date '2010/1/1'  -Hour 8  -Minute 0  -Second 15

# Calculate the interval between the two dates.
$Interval = $Date2 - $Date1
"{0} - {1} = {2}" -f $Date2, $Date1, ($Interval.ToString())

#  Display individual properties of the resulting TimeSpan object.
"   {0,-35} {1,20}"    -f "Value of Days Component:", $Interval.Days
"   {0,-35} {1,20}"    -f "Total Number of Days:", $Interval.TotalDays
"   {0,-35} {1,20}"    -f "Value of Hours Component:", $Interval.Hours
"   {0,-35} {1,20}"    -f "Total Number of Hours:", $Interval.TotalHours
"   {0,-35} {1,20}"    -f "Value of Minutes Component:", $Interval.Minutes
"   {0,-35} {1,20}"    -f "Total Number of Minutes:", $Interval.TotalMinutes
"   {0,-35} {1,20:N0}" -f "Value of Seconds Component:", $Interval.Seconds
"   {0,-35} {1,20:N0}" -f "Total Number of Seconds:", $Interval.TotalSeconds
"   {0,-35} {1,20:N0}" -f "Value of Milliseconds Component:", $Interval.Milliseconds
"   {0,-35} {1,20:N0}" -f "Total Number of Milliseconds:", $Interval.TotalMilliseconds
"   {0,-35} {1,20:N0}" -f "Ticks:", $Interval.Ticks

<# This sample produces the following output:

18/08/2010 13:30:30 - 01/01/2010 08:00:15 = 229.05:30:15
   Value of Days Component:                             229
   Total Number of Days:                   229.229340277778
   Value of Hours Component:                              5
   Total Number of Hours:                  5501.50416666667
   Value of Minutes Component:                           30
   Total Number of Minutes:                       330090.25
   Value of Seconds Component:                           15
   Total Number of Seconds:                      19,805,415
   Value of Milliseconds Component:                       0
   Total Number of Milliseconds:             19,805,415,000
   Ticks:                               198,054,150,000,000
#>

Hinweise

Weitere Informationen zu dieser API finden Sie unter Ergänzende API-Hinweise für timeSpan.

Konstruktoren

TimeSpan(Int32, Int32, Int32)	Initialisiert eine neue Instanz der TimeSpan Struktur auf eine angegebene Anzahl von Stunden, Minuten und Sekunden.
TimeSpan(Int32, Int32, Int32, Int32)	Initialisiert eine neue Instanz der TimeSpan Struktur auf eine bestimmte Anzahl von Tagen, Stunden, Minuten und Sekunden.
TimeSpan(Int32, Int32, Int32, Int32, Int32)	Initialisiert eine neue Instanz der TimeSpan Struktur auf eine bestimmte Anzahl von Tagen, Stunden, Minuten, Sekunden und Millisekunden.
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)	Initialisiert eine neue Instanz der TimeSpan Struktur auf eine bestimmte Anzahl von Tagen, Stunden, Minuten, Sekunden, Millisekunden und Mikrosekunden.
TimeSpan(Int64)	Initialisiert eine neue Instanz der TimeSpan Struktur auf die angegebene Anzahl von Teilstrichen.

Felder

MaxValue	Stellt den maximalen TimeSpan Wert dar. Dieses Feld ist schreibgeschützt.
MinValue	Stellt den minimalen TimeSpan Wert dar. Dieses Feld ist schreibgeschützt.
NanosecondsPerTick	Stellt die Anzahl der Nanosekunden pro Teilstrich dar. Dieses Feld ist konstant.
TicksPerDay	Stellt die Anzahl der Teilstriche in 1 Tag dar. Dieses Feld ist konstant.
TicksPerHour	Stellt die Anzahl der Teilstriche in einer Stunde dar. Dieses Feld ist konstant.
TicksPerMicrosecond	Stellt die Anzahl der Teilstriche in 1 Mikrosekunden dar. Dieses Feld ist konstant.
TicksPerMillisecond	Stellt die Anzahl der Teilstriche in 1 Millisekunden dar. Dieses Feld ist konstant.
TicksPerMinute	Stellt die Anzahl der Teilstriche in 1 Minute dar. Dieses Feld ist konstant.
TicksPerSecond	Stellt die Anzahl der Teilstriche in 1 Sekunde dar.
Zero	Stellt den Null-TimeSpan-Wert dar. Dieses Feld ist schreibgeschützt.

Eigenschaften

Days	Ruft die Tage-Komponente des Durch die aktuellen TimeSpan Struktur dargestellten Zeitintervalls ab.
Hours	Ruft die Stundenkomponente des Durch die aktuellen TimeSpan Struktur dargestellten Zeitintervalls ab.
Microseconds	Ruft die Mikrosekundenkomponente des Zeitintervalls ab, das durch die aktuelle TimeSpan-Struktur dargestellt wird.
Milliseconds	Ruft die Millisekundenkomponente des Zeitintervalls ab, das durch die aktuelle TimeSpan-Struktur dargestellt wird.
Minutes	Ruft die Minutenkomponente des Durch die aktuellen TimeSpan Struktur dargestellten Zeitintervalls ab.
Nanoseconds	Ruft die Nanosekundenkomponente des Zeitintervalls ab, das durch die aktuelle TimeSpan-Struktur dargestellt wird.
Seconds	Ruft die Sekundenkomponente des Zeitintervalls ab, das durch die aktuelle TimeSpan-Struktur dargestellt wird.
Ticks	Ruft die Anzahl der Teilstriche ab, die den Wert der aktuellen TimeSpan Struktur darstellen.
TotalDays	Ruft den Wert der aktuellen TimeSpan Struktur ab, die in ganzen und bruchteilalen Tagen ausgedrückt wird.
TotalHours	Ruft den Wert der aktuellen TimeSpan Struktur in ganzen und Bruchstunden ausgedrückt ab.
TotalMicroseconds	Ruft den Wert der aktuellen TimeSpan-Struktur ab, die in ganzen und bruchteilalen Mikrosekunden ausgedrückt wird.
TotalMilliseconds	Ruft den Wert der aktuellen TimeSpan Struktur ab, die in ganzen und bruchteilalen Millisekunden ausgedrückt wird.
TotalMinutes	Ruft den Wert der aktuellen TimeSpan Struktur in ganzen und Bruchminuten ausgedrückt ab.
TotalNanoseconds	Ruft den Wert der aktuellen TimeSpan Struktur ab, die in ganzen und bruchteilalen Nanosekunden ausgedrückt wird.
TotalSeconds	Ruft den Wert der aktuellen TimeSpan Struktur ab, die in ganzen und bruchteilalen Sekunden ausgedrückt wird.

Methoden

Add(TimeSpan)	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert die Summe des angegebenen TimeSpan -Objekts und dieser Instanz ist.
Compare(TimeSpan, TimeSpan)	Vergleicht zwei TimeSpan Werte und gibt eine ganze Zahl zurück, die angibt, ob der erste Wert kürzer als, gleich oder länger als der zweite Wert ist.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob diese Instanz kürzer als, gleich oder länger als das angegebene Objekt ist.
CompareTo(TimeSpan)	Vergleicht diese Instanz mit einem angegebenen TimeSpan -Objekt und gibt eine ganze Zahl zurück, die angibt, ob diese Instanz kürzer als, gleich oder länger als das TimeSpan -Objekt ist.
Divide(Double)	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert das Ergebnis ist, diese Instanz durch die angegebene divisorzu dividieren.
Divide(TimeSpan)	Gibt einen neuen Double Wert zurück, der das Ergebnis der Aufteilung dieser Instanz durch tsist.
Duration()	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert der absolute Wert des aktuellen TimeSpan -Objekts ist.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz einem angegebenen Objekt entspricht.
Equals(TimeSpan)	Gibt einen Wert zurück, der angibt, ob diese Instanz einem angegebenen TimeSpan -Objekt entspricht.
Equals(TimeSpan, TimeSpan)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Instanzen von TimeSpan gleich sind.
FromDays(Double)	Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Tagen darstellt, wobei die Spezifikation auf die nächste Millisekunden genau ist.
FromHours(Double)	Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Stunden darstellt, wobei die Spezifikation auf die nächste Millisekunden genau ist.
FromMicroseconds(Double)	Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Mikrosekunden darstellt.
FromMilliseconds(Double)	Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Millisekunden darstellt.
FromMinutes(Double)	Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Minuten darstellt, wobei die Spezifikation auf die nächste Millisekunden genau ist.
FromSeconds(Double)	Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Sekunden darstellt, wobei die Spezifikation auf die nächste Millisekunden genau ist.
FromTicks(Int64)	Gibt einen TimeSpan zurück, der eine angegebene Zeit darstellt, wobei sich die Spezifikation in Einheiten von Teilstrichen befindet.
GetHashCode()	Gibt einen Hashcode für diese Instanz zurück.
Multiply(Double)	Gibt ein neues TimeSpan -Objekt zurück, das das Ergebnis der Multiplikation dieser Instanz und der angegebenen factorist.
Negate()	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert der negierte Wert dieser Instanz ist.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Wandelt die Spandarstellung eines Zeitintervalls mithilfe der angegebenen kulturspezifischen Formatinformationen in das TimeSpan Äquivalent um.
Parse(String)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Entsprechung.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in die TimeSpan Entsprechung mithilfe der angegebenen kulturspezifischen Formatinformationen.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenspanne eines Zeitintervalls in die TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
ParseExact(String, String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format-, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
ParseExact(String, String[], IFormatProvider)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe des angegebenen Arrays von Formatzeichenfolgen und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
Subtract(TimeSpan)	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert der Unterschied zwischen dem angegebenen TimeSpan -Objekt und dieser Instanz ist.
ToString()	Konvertiert den Wert des aktuellen TimeSpan-Objekts in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den Wert des aktuellen TimeSpan -Objekts in die entsprechende Zeichenfolgendarstellung mithilfe des angegebenen Formats.
ToString(String, IFormatProvider)	Konvertiert den Wert des aktuellen TimeSpan -Objekts in die entsprechende Zeichenfolgendarstellung mithilfe der angegebenen Format- und kulturspezifischen Formatierungsinformationen.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz als UTF-8 in die bereitgestellte Bytespanne zu formatieren.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Zeitbereichszahlinstanz in den angegebenen Bereich von Zeichen zu formatieren.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Konvertiert die Spannweitendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen kulturspezifischen Formatierungsinformationen und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
TryParse(ReadOnlySpan<Char>, TimeSpan)	Konvertiert die Spandarstellung eines Zeitintervalls in dessen TimeSpan Äquivalent und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
TryParse(String, IFormatProvider, TimeSpan)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Äquivalent mithilfe der angegebenen kulturspezifischen Formatierungsinformationen und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
TryParse(String, TimeSpan)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Äquivalent und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Konvertiert die angegebene Spannweitendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Konvertiert die angegebene Spannweitendarstellung eines Zeitintervalls in dessen TimeSpan Äquivalent mithilfe der angegebenen Format-, kulturspezifischen Formatinformationen und Formatvorlagen und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Konvertiert die angegebene Spannweitendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Konvertiert die angegebene Spannweitendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in dessen TimeSpan Entsprechung mithilfe des angegebenen Formats, kulturspezifischer Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Konvertiert die angegebene Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate und kulturspezifischen Formatinformationen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Konvertiert die angegebene Zeichenfolgendarstellung eines Zeitintervalls in seine TimeSpan Entsprechung mithilfe der angegebenen Formate, kulturspezifischen Formatinformationen und Formatvorlagen. Das Format der Zeichenfolgendarstellung muss genau mit einem der angegebenen Formate übereinstimmen.

Operatoren

Addition(TimeSpan, TimeSpan)	Fügt zwei angegebene TimeSpan Instanzen hinzu.
Division(TimeSpan, Double)	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert das Ergebnis ist, die angegebene timeSpan durch die angegebene divisorzu dividieren.
Division(TimeSpan, TimeSpan)	Gibt einen neuen Double Wert zurück, der das Ergebnis der Aufteilung t1 durch t2ist.
Equality(TimeSpan, TimeSpan)	Gibt an, ob zwei TimeSpan Instanzen gleich sind.
GreaterThan(TimeSpan, TimeSpan)	Gibt an, ob eine angegebene TimeSpan größer als eine andere angegebene TimeSpanist.
GreaterThanOrEqual(TimeSpan, TimeSpan)	Gibt an, ob eine angegebene TimeSpan größer oder gleich einem anderen angegebenen TimeSpanist.
Inequality(TimeSpan, TimeSpan)	Gibt an, ob zwei TimeSpan Instanzen nicht gleich sind.
LessThan(TimeSpan, TimeSpan)	Gibt an, ob ein angegebenes TimeSpan kleiner als ein anderer angegebener TimeSpanist.
LessThanOrEqual(TimeSpan, TimeSpan)	Gibt an, ob eine angegebene TimeSpan kleiner oder gleich einem anderen angegebenen TimeSpanist.
Multiply(Double, TimeSpan)	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert das Ergebnis der Multiplikation der angegebenen factor und der angegebenen timeSpan Instanz ist.
Multiply(TimeSpan, Double)	Gibt ein neues TimeSpan -Objekt zurück, dessen Wert das Ergebnis der Multiplikation der angegebenen timeSpan Instanz und der angegebenen factorist.
Subtraction(TimeSpan, TimeSpan)	Subtrahiert eine angegebene TimeSpan von einem anderen angegebenen TimeSpan.
UnaryNegation(TimeSpan)	Gibt einen TimeSpan zurück, dessen Wert der negierten Wert der angegebenen Instanz ist.
UnaryPlus(TimeSpan)	Gibt die angegebene Instanz von TimeSpanzurück.

Weitere Informationen

• DateTime
• DateTimeOffset
• Calendar