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
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
[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
[<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
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan)
Vererbung
TimeSpan
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird ein -Objekt instanziiert, TimeSpan das den Unterschied zwischen zwei Datumsangaben darstellt. Anschließend werden die Eigenschaften TimeSpan des 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.
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

Ein -Objekt stellt ein Zeitintervall (Dauer oder verstrichene Zeit) dar, das als positive oder negative Anzahl von Tagen, Stunden, Minuten, Sekunden und Sekundenbruchteilen TimeSpan gemessen wird. Die -Struktur kann auch zur Darstellung der Tageszeit verwendet werden, jedoch nur, wenn die Uhrzeit nicht mit TimeSpan einem bestimmten Datum verknüpft ist. Andernfalls sollte DateTime stattdessen die - oder DateTimeOffset -Struktur verwendet werden. (Weitere Informationen zur Verwendung der -Struktur zur Veröffentlichung der Tageszeit finden Sie unter TimeSpan Choosing Between DateTime, DateTimeOffset, TimeSpan, and TimeZoneInfo.)

Hinweis

Ein -Wert stellt ein Zeitintervall dar und kann als eine bestimmte Anzahl von TimeSpan Tagen, Stunden, Minuten, Sekunden und Millisekunden ausgedrückt werden. Da es ein allgemeines Intervall ohne Verweis auf einen bestimmten Start- oder Endpunkt darstellt, kann es nicht als Jahre und Monate ausgedrückt werden, die beide eine variable Anzahl von Tagen haben. Sie unterscheidet sich von einem -Wert, der ein Datum und eine Uhrzeit ohne Verweis auf eine bestimmte Zeitzone darstellt, oder von einem -Wert, der einen bestimmten DateTime DateTimeOffset Zeitpunkt darstellt.

Die größte Zeiteinheit, die die Struktur TimeSpan zum Messen der Dauer verwendet, ist ein Tag. Zeitintervalle werden zur Konsistenz in Tagen gemessen, da die Anzahl der Tage in größeren Zeiteinheiten, z. B. Monaten und Jahren, variiert.

Der Wert eines TimeSpan -Objekts ist die Anzahl von Ticks, die dem dargestellten Zeitintervall entspricht. Ein Teilstrich ist gleich 100 Nanosekunden oder ein Zehn-Millionstelsekunden-Wert. Der Wert eines TimeSpan -Objekts kann von bis TimeSpan.MinValue TimeSpan.MaxValue reichen.

Instanziieren eines TimeSpan-Werts

Sie können einen Wert auf TimeSpan verschiedene Weise instanziieren:

  • Durch Aufrufen des impliziten parameterlosen Konstruktors. Dadurch wird ein -Objekt erstellt, dessen Wert TimeSpan.Zero ist, wie im folgenden Beispiel gezeigt.

    TimeSpan interval = new TimeSpan();
    Console.WriteLine(interval.Equals(TimeSpan.Zero));    // Displays "True".
    
    Dim interval As New TimeSpan()
    Console.WriteLine(interval.Equals(TimeSpan.Zero))     ' Displays "True".
    
  • Durch Aufrufen eines seiner expliziten Konstruktoren. Im folgenden Beispiel wird ein -Wert mit einer angegebenen Anzahl von TimeSpan Stunden, Minuten und Sekunden initialisiert.

    TimeSpan interval = new TimeSpan(2, 14, 18);
    Console.WriteLine(interval.ToString());              
    
    // Displays "02:14:18".
    
    Dim interval As New TimeSpan(2, 14, 18)
    Console.WriteLine(interval.ToString())                ' Displays "02:14:18".
    
  • Durch Aufrufen einer Methode oder Ausführen eines Vorgangs, der einen Wert TimeSpan zurückgibt. Beispielsweise können Sie einen Wert instanziieren, der das Intervall zwischen zwei Datums- und Uhrzeitwerten darstellt, wie TimeSpan im folgenden Beispiel gezeigt.

    DateTime departure = new DateTime(2010, 6, 12, 18, 32, 0);
    DateTime arrival = new DateTime(2010, 6, 13, 22, 47, 0);
    TimeSpan travelTime = arrival - departure;  
    Console.WriteLine("{0} - {1} = {2}", arrival, departure, travelTime);      
    
    // The example displays the following output:
    //       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
    
    Dim departure As DateTime = #06/12/2010 6:32PM#
    Dim arrival As DateTime = #06/13/2010 10:47PM#
    Dim travelTime As TimeSpan = arrival - departure  
    Console.WriteLine("{0} - {1} = {2}", arrival, departure, travelTime)      
    ' The example displays the following output:
    '       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
    

    Sie können ein -Objekt auch TimeSpan auf diese Weise mit einem Nullzeitwert initialisieren, wie im folgenden Beispiel gezeigt.

       Random rnd = new Random();
    
       TimeSpan timeSpent = TimeSpan.Zero;
    
       timeSpent += GetTimeBeforeLunch();
       timeSpent += GetTimeAfterLunch();
    
       Console.WriteLine("Total time: {0}", timeSpent);
    
       TimeSpan GetTimeBeforeLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
       
       TimeSpan GetTimeAfterLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
    
       // The example displays output like the following:
       //        Total time: 08:00:00
    
    Module Example
       Dim rnd As New Random()
       
       Public Sub Main()
          Dim timeSpent As TimeSpan = TimeSpan.Zero
    
          timeSpent += GetTimeBeforeLunch()
          timeSpent += GetTimeAfterLunch()
    
          Console.WriteLine("Total time: {0}", timeSpent)
       End Sub
       
       Private Function GetTimeBeforeLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
       End Function
       
       Private Function GetTimeAfterLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
       End Function
    End Module
    ' The example displays output like the following:
    '       Total time: 08:00:00
    

    TimeSpan -Werte werden von arithmetischen Operatoren und Methoden der DateTime -, DateTimeOffset - und -Strukturen TimeSpan zurückgegeben.

  • Durch Analyse der Zeichenfolgendarstellung eines TimeSpan Werts. Sie können die Methoden und Parse TryParse verwenden, um Zeichenfolgen, die Zeitintervalle enthalten, in Werte TimeSpan zu konvertieren. Im folgenden Beispiel wird die Parse -Methode verwendet, um ein Array von Zeichenfolgen in Werte TimeSpan zu konvertieren.

    string[] values = { "12", "31.", "5.8:32:16", "12:12:15.95", ".12"};
    foreach (string value in values)
    {
       try {
          TimeSpan ts = TimeSpan.Parse(value);
          Console.WriteLine("'{0}' --> {1}", value, ts);
       }
       catch (FormatException) {
          Console.WriteLine("Unable to parse '{0}'", value);
       }
       catch (OverflowException) {
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value);
       }   
    }
    
    // The example displays the following output:
    //       '12' --> 12.00:00:00
    //       Unable to parse '31.'
    //       '5.8:32:16' --> 5.08:32:16
    //       '12:12:15.95' --> 12:12:15.9500000
    //       Unable to parse '.12'
    
    Dim values() As String = { "12", "31.", "5.8:32:16", "12:12:15.95", ".12"}
    For Each value As String In values
       Try
          Dim ts As TimeSpan = TimeSpan.Parse(value)
          Console.WriteLine("'{0}' --> {1}", value, ts)
       Catch e As FormatException
          Console.WriteLine("Unable to parse '{0}'", value)
       Catch e As OverflowException
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value)
       End Try   
    Next
    ' The example displays the following output:
    '       '12' --> 12.00:00:00
    '       Unable to parse '31.'
    '       '5.8:32:16' --> 5.08:32:16
    '       '12:12:15.95' --> 12:12:15.9500000
    '       Unable to parse '.12'
    

    Darüber hinaus können Sie das genaue Format der Eingabezeichenfolge definieren, die analysiert und in einen Wert konvertiert werden soll, indem Sie TimeSpan die - oder ParseExact -Methode TryParseExact aufrufen.

Ausführen von Vorgängen für TimeSpan-Werte

Sie können Zeitdauern entweder mithilfe der Operatoren und oder durch Aufrufen der Methoden und hinzufügen Addition Subtraction und Add Subtract subtrahieren. Sie können auch zwei Zeitdauern vergleichen, indem Sie Compare die Methoden , und CompareTo Equals aufrufen. Die TimeSpan -Struktur enthält auch die Duration -Methode Negate und die -Methode, die Zeitintervalle in positive und negative Werte konvertiert.

Der Wertebereich TimeSpan ist MinValue bis MaxValue .

Formatieren eines TimeSpan-Werts

Ein TimeSpan Wert kann als [ ] d dargestellt - *werden.*hh:mm:ss. ff, wobei das optionale Minuszeichen ein negatives Zeitintervall angibt, die d-Komponente Tage, hh stunden, gemessen an einer 24-Stunden-Uhr, mm minuten, ss sekunden und ff Sekundenbruchteilen. Das heißt, ein Zeitintervall besteht aus einer positiven oder negativen Anzahl von Tagen ohne Tageszeit oder einer Anzahl von Tagen mit einer Tageszeit oder nur einer Tageszeit.

Ab dem .NET Framework 4 unterstützt die -Struktur kulturempfindliche Formatierungen über die Überladungen ihrer -Methode, die einen Wert in seine Zeichenfolgendarstellung TimeSpan ToString TimeSpan konvertiert. Die Standardmethode gibt ein Zeitintervall zurück, indem ein invariantes Format verwendet wird, das mit dem Rückgabewert in früheren Versionen des TimeSpan.ToString() -.NET Framework. Mit TimeSpan.ToString(String) der Überladung können Sie eine Formatzeichenfolge angeben, die die Zeichenfolgendarstellung des Zeitintervalls definiert. Mit der Überladung können Sie eine Formatzeichenfolge und die Kultur angeben, deren Formatierungskonventionen verwendet werden, um die Zeichenfolgendarstellung TimeSpan.ToString(String, IFormatProvider) des Zeitintervalls zu erstellen. TimeSpan unterstützt sowohl Standardformatzeichenfolgen als auch benutzerdefinierte Formatzeichenfolgen. (Weitere Informationen finden Sie unter Standard-TimeSpan-Formatzeichenfolgen und Benutzerdefinierte TimeSpan-Formatzeichenfolgen.) Allerdings sind nur Standardformatzeichenfolgen kulturempfindlich.

Wiederherstellen der Legacy-TimeSpan-Formatierung

In einigen Fällen schlägt Code, der Erfolgreich Werte in .NET Framework 3.5 und früheren Versionen formatiert, in .NET Framework TimeSpan 4 fehl. Dies ist am häufigsten in Code, der eine <TimeSpan_LegacyFormatMode>-Elementmethode aufruft, um einen Wert TimeSpan mit einer Formatzeichenfolge zu formatieren. Das folgende Beispiel formatiert erfolgreich einen Wert in .NET Framework 3.5 und früheren Versionen, löst jedoch eine Ausnahme in .NET Framework 4 und TimeSpan höher aus. Beachten Sie, dass versucht wird, einen Wert mithilfe eines nicht unterstützten Formatbezeichners zu formatieren, der in version .NET Framework 3.5 und früheren Versionen TimeSpan ignoriert wird.

ShowFormattingCode();
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format    

Console.WriteLine("---");

ShowParsingCode();
// Output:
//       000000006 --> 6.00:00:00

void ShowFormattingCode()
{
   TimeSpan interval = new TimeSpan(12, 30, 45);
   string output;
   try {
      output = String.Format("{0:r}", interval);
   }
   catch (FormatException) {
      output = "Invalid Format";
   }
   Console.WriteLine(output);
}

void ShowParsingCode()
{
   string value = "000000006";
   try {
      TimeSpan interval = TimeSpan.Parse(value);
      Console.WriteLine("{0} --> {1}", value, interval);
   }
   catch (FormatException) {
      Console.WriteLine("{0}: Bad Format", value);
   }   
   catch (OverflowException) {
      Console.WriteLine("{0}: Overflow", value);
   }
}
Dim interval As New TimeSpan(12, 30, 45)
Dim output As String
Try
   output = String.Format("{0:r}", interval)
Catch e As FormatException
   output = "Invalid Format"
End Try
Console.WriteLine(output)
' Output from .NET Framework 3.5 and earlier versions:
'       12:30:45
' Output from .NET Framework 4:
'       Invalid Format

Wenn Sie den Code nicht ändern können, können Sie die Legacyformatierung von Werten TimeSpan auf eine der folgenden Arten wiederherstellen:

  • Durch Erstellen einer Konfigurationsdatei, die das<TimeSpan_LegacyFormatMode> enthält. Wenn Sie das -Attribut enabled dieses Elements auf true festlegen, wird die TimeSpan Legacyformatierung anwendungsspezifische wiederhergestellt.

  • Durch Festlegen des Kompatibilitätsschalters "NetFx40_TimeSpanLegacyFormatMode" beim Erstellen einer Anwendungsdomäne. Dies ermöglicht die TimeSpan Legacyformatierung auf Anwendungsdomänenbasis. Im folgenden Beispiel wird eine Anwendungsdomäne erstellt, die TimeSpan Legacyformatierung verwendet.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          AppDomainSetup appSetup = new AppDomainSetup();
          appSetup.SetCompatibilitySwitches( new string[] { "NetFx40_TimeSpanLegacyFormatMode" } );
          AppDomain legacyDomain = AppDomain.CreateDomain("legacyDomain", 
                                                          null, appSetup);
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe");
       }
    }
    
    Module Example
       Public Sub Main()
          Dim appSetup As New AppDomainSetup()
          appSetup.SetCompatibilitySwitches( { "NetFx40_TimeSpanLegacyFormatMode" } )
          Dim legacyDomain As AppDomain = AppDomain.CreateDomain("legacyDomain", 
                                                                 Nothing, appSetup)
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe")
       End Sub
    End Module
    

    Wenn der folgende Code in der neuen Anwendungsdomäne ausgeführt wird, wird das Legacyformatierungsverhalten TimeSpan wie zurückverwendet.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          TimeSpan interval = DateTime.Now - DateTime.Now.Date;
          string msg = String.Format("Elapsed Time Today: {0:d} hours.",
                                     interval);
          Console.WriteLine(msg);
       }
    }
    // The example displays the following output:
    //       Elapsed Time Today: 01:40:52.2524662 hours.
    
    Module Example
       Public Sub Main()
          Dim interval As TimeSpan = Date.Now - Date.Now.Date
          Dim msg As String = String.Format("Elapsed Time Today: {0:d} hours.",
                                             interval)
          Console.WriteLine(msg)
       End Sub
    End Module
    ' The example displays output like the following:
    '       Elapsed Time Today: 01:40:52.2524662 hours.
    

Konstruktoren

TimeSpan(Int32, Int32, Int32)

Initialisiert eine neue Instanz der TimeSpan-Struktur mit der angegebenen Anzahl von Stunden, Minuten und Sekunden.

TimeSpan(Int32, Int32, Int32, Int32)

Initialisiert eine neue Instanz der TimeSpan-Struktur mit der angegebenen Anzahl von Tagen, Stunden, Minuten und Sekunden.

TimeSpan(Int32, Int32, Int32, Int32, Int32)

Initialisiert eine neue Instanz der TimeSpan-Struktur mit der angegebenen Anzahl von Tagen, Stunden, Minuten, Sekunden und Millisekunden.

TimeSpan(Int64)

Initialisiert eine neue Instanz der TimeSpan-Struktur mit der angegebenen Anzahl von Ticks.

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.

TicksPerDay

Stellt die Anzahl der Ticks pro Tag dar. Dieses Feld ist konstant.

TicksPerHour

Stellt die Anzahl der Ticks pro Stunde dar. Dieses Feld ist konstant.

TicksPerMillisecond

Stellt die Anzahl der Ticks pro Millisekunde dar. Dieses Feld ist konstant.

TicksPerMinute

Stellt die Anzahl der Ticks pro Minute dar. Dieses Feld ist konstant.

TicksPerSecond

Stellt die Anzahl der Ticks pro Sekunde dar.

Zero

Stellt den TimeSpan-Wert für 0 (null) dar. Dieses Feld ist schreibgeschützt.

Eigenschaften

Days

Ruft die Tageskomponente des Zeitintervalls ab, das durch die aktuelle TimeSpan-Struktur dargestellt wird.

Hours

Ruft die Stundenkomponente 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 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 Ticks ab, die den Wert der aktuellen TimeSpan-Struktur darstellt.

TotalDays

Ruft den Wert der aktuellen TimeSpan-Struktur in ganzen Tagen und Bruchteilen von Tagen ab.

TotalHours

Ruft den Wert der aktuellen TimeSpan-Struktur in ganzen Stunden und Bruchteilen von Stunden ab.

TotalMilliseconds

Ruft den Wert der aktuellen TimeSpan-Struktur in ganzen Millisekunden und Bruchteilen von Millisekunden ab.

TotalMinutes

Ruft den Wert der aktuellen TimeSpan-Struktur in ganzen Minuten und Bruchteilen von Minuten ab.

TotalSeconds

Ruft den Wert der aktuellen TimeSpan-Struktur in ganzen Sekunden und Bruchteilen von Sekunden ab.

Methoden

Add(TimeSpan)

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert die Summe aus dem angegebenen TimeSpan-Objekt 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 oder länger als der zweite Wert ist oder ob beide Werte die gleiche Länge aufweisen.

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob diese Instanz kürzer oder länger als das angegebene Objekt ist oder ob sie die gleiche Länge aufweist.

CompareTo(TimeSpan)

Vergleicht diese Instanz mit einem angegebenen TimeSpan-Objekt und gibt eine ganze Zahl zurück, die angibt, ob diese Instanz kürzer oder länger als das angegebene TimeSpan-Objekt ist oder ob sie die gleiche Länge aufweist.

Divide(Double)

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert das Ergebnis der Division dieser Instanz und des angegebenen divisor ist.

Divide(TimeSpan)

Gibt einen neuen Double-Wert zurück, der das Ergebnis der Division dieser Instanz durch den angegebenen ts ist.

Duration()

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert den absoluten Wert des aktuellen TimeSpan-Objekts darstellt.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

Equals(TimeSpan)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen TimeSpan-Objekt ist.

Equals(TimeSpan, TimeSpan)

Gibt einen Wert zurück, der angibt, ob zwei angegebene Instanzen von TimeSpan gleich sind.

FromDays(Double)

Gibt eine TimeSpan zurück, die eine angegebene Anzahl von Tagen darstellt. Die Angabe wird auf die nächste Millisekunde gerundet.

FromHours(Double)

Gibt eine TimeSpan zurück, die eine angegebene Anzahl von Stunden darstellt. Die Angabe wird auf die nächste Millisekunde gerundet.

FromMilliseconds(Double)

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

FromMinutes(Double)

Gibt eine TimeSpan zurück, die eine angegebene Anzahl von Minuten darstellt. Die Angabe wird auf die nächste Millisekunde gerundet.

FromSeconds(Double)

Gibt eine TimeSpan zurück, die eine angegebene Anzahl von Sekunden darstellt. Die Angabe wird auf die nächste Millisekunde gerundet.

FromTicks(Int64)

Gibt eine TimeSpan zurück, die einen angegebenen Zeitraum darstellt. Die Angabe erfolgt in der Einheit Ticks.

GetHashCode()

Gibt einen Hashcode für diese Instanz zurück.

Multiply(Double)

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert das Ergebnis der Multiplikation dieser Instanz und des angegebenen factor ist.

Negate()

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert der negierte Wert dieser Instanz ist.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Konvertiert die Spannendarstellung eines Zeitintervalls unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan.

Parse(String)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls in die entsprechende TimeSpan.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

Konvertiert die Zeichenspanne eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

ParseExact(String, String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

ParseExact(String, String[], IFormatProvider)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Arrays von Formatierungszeichenfolgen und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

Subtract(TimeSpan)

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert die Differenz 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 unter Verwendung des angegebenen Formats in die entsprechende Zeichenfolgendarstellung.

ToString(String, IFormatProvider)

Konvertiert den Wert des aktuellen TimeSpan-Objekts unter Verwendung des angegebenen Formats und der angegebenen kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen Instanz einer Zeitspannenzahl in die angegebene Zeichenspanne zu formatieren.

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, 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(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.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Konvertiert die angegebene Spannendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die angegebene Spannendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats, der kulturspezifischen Formatierungsinformationen und der Stile in die entsprechende TimeSpan und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

Konvertiert die angegebene Spannendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die angegebene Spannendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

TryParseExact(String, String, IFormatProvider, TimeSpan)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss dem angegebenen Format genau entsprechen.

TryParseExact(String, String[], IFormatProvider, TimeSpan)

Konvertiert die angegebene Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung des angegebenen Formats und der kulturspezifischen Formatierungsinformationen in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Konvertiert die angegebene Zeichenfolgendarstellung eines Zeitintervalls unter Verwendung der angegebenen Formate, der kulturspezifischen Formatierungsinformationen und Stile in die entsprechende TimeSpan. Das Format der Zeichenfolgendarstellung muss einem der angegebenen Formate genau entsprechen.

Operatoren

Addition(TimeSpan, TimeSpan)

Addiert zwei angegebene TimeSpan-Instanzen.

Division(TimeSpan, Double)

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert das Ergebnis der Division der timeSpan-Instanz und des angegebenen divisor ist.

Division(TimeSpan, TimeSpan)

Gibt einen neuen Double-Wert zurück, der das Ergebnis der Division der t1-Instanz durch den angegebenen t2 ist.

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 TimeSpan ist.

GreaterThanOrEqual(TimeSpan, TimeSpan)

Gibt an, ob eine angegebene TimeSpan größer oder gleich einer anderen angegebenen TimeSpan ist.

Inequality(TimeSpan, TimeSpan)

Gibt an, ob zwei TimeSpan-Instanzen ungleich sind.

LessThan(TimeSpan, TimeSpan)

Gibt an, ob eine angegebene TimeSpan kleiner als eine andere angegebene TimeSpan ist.

LessThanOrEqual(TimeSpan, TimeSpan)

Gibt an, ob eine angegebene TimeSpan kleiner oder gleich einer anderen angegebenen TimeSpan ist.

Multiply(Double, TimeSpan)

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert das Ergebnis der Multiplikation von factor und der angegebenen timeSpan-Instanz ist

Multiply(TimeSpan, Double)

Gibt ein neues TimeSpan-Objekt zurück, dessen Wert das Ergebnis der Multiplikation der timeSpan-Instanz und des angegebenen factor-Elements ist

Subtraction(TimeSpan, TimeSpan)

Subtrahiert eine angegebene TimeSpan von einer anderen angegebenen TimeSpan.

UnaryNegation(TimeSpan)

Gibt eine TimeSpan zurück, deren Wert der negierte Wert der angegebenen Instanz ist.

UnaryPlus(TimeSpan)

Gibt die angegebene Instanz von TimeSpan zurück.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Ganzzahl zurück, die angibt, ob diese Instanz kürzer oder länger als das angegebene Objekt ist oder ob sie die gleiche Länge aufweist.

Gilt für

Siehe auch