Freigeben über


TimeSpan Struktur

Definition

Stellt ein Zeitintervall dar.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
public value class TimeSpan : IComparable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
[System.Serializable]
public struct TimeSpan : IComparable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
type TimeSpan = struct
    interface IFormattable
type TimeSpan = struct
    interface ISpanFormattable
    interface IFormattable
type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
    interface IUtf8SpanFormattable
[<System.Serializable>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
    interface IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), ISpanFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan)
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan), IUtf8SpanFormattable
Public Structure TimeSpan
Implements IComparable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan)
Vererbung
TimeSpan
Attribute
Implementiert

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.

FromDays(Int32)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine angegebene Anzahl von Tagen.

FromDays(Int32, Int32, Int64, Int64, Int64, Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine bestimmte Anzahl von Tagen, Stunden, Minuten, Sekunden, Millisekunden und Mikrosekunden.

FromHours(Double)

Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Stunden darstellt, wobei die Spezifikation auf die nächste Millisekunden genau ist.

FromHours(Int32)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine bestimmte Anzahl von Stunden.

FromHours(Int32, Int64, Int64, Int64, Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine bestimmte Anzahl von Stunden, Minuten, Sekunden, Millisekunden und Mikrosekunden.

FromMicroseconds(Double)

Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Mikrosekunden darstellt.

FromMicroseconds(Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine angegebene Anzahl von Mikrosekunden.

FromMilliseconds(Double)

Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Millisekunden darstellt.

FromMilliseconds(Int64, Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine angegebene Anzahl von Millisekunden und Mikrosekunden.

FromMinutes(Double)

Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Minuten darstellt, wobei die Spezifikation auf die nächste Millisekunden genau ist.

FromMinutes(Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine angegebene Anzahl von Minuten.

FromMinutes(Int64, Int64, Int64, Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine bestimmte Anzahl von Minuten, Sekunden, Millisekunden und Mikrosekunden.

FromSeconds(Double)

Gibt einen TimeSpan zurück, der eine angegebene Anzahl von Sekunden darstellt, wobei die Spezifikation auf die nächste Millisekunden genau ist.

FromSeconds(Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine angegebene Anzahl von Sekunden.

FromSeconds(Int64, Int64, Int64)

Initialisiert eine neue Instanz der TimeSpan Struktur auf eine angegebene Anzahl von Sekunden, Millisekunden und Mikrosekunden.

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.

Explizite Schnittstellenimplementierungen

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

Gilt für:

Weitere Informationen