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
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>
[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>
[<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
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 TimeSpan Eigenschaften 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.
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

Ein TimeSpan -Objekt stellt ein Zeitintervall (Dauer der Zeit oder verstrichene Zeit) dar, das als positive oder negative Anzahl von Tagen, Stunden, Minuten, Sekunden und Sekundenbruchteilen gemessen wird. Die TimeSpan -Struktur kann auch verwendet werden, um die Tageszeit darzustellen, aber nur, wenn die Uhrzeit nicht mit einem bestimmten Datum zusammenhängt. Andernfalls sollte stattdessen die DateTime -Struktur oder DateTimeOffset verwendet werden. (Weitere Informationen zur Verwendung der TimeSpan Struktur zur Widerspiegelung der Tageszeit finden Sie unter Auswählen zwischen DateTime, DateTimeOffset, TimeSpan und TimeZoneInfo.)

Hinweis

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

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

Der Wert eines TimeSpan Objekts ist die Anzahl von Ticks, die dem dargestellten Zeitintervall entsprechen. Ein Tick entspricht 100 Nanosekunden oder einer Zehnmillionstel Sekunde. Der Wert eines TimeSpan Objekts kann von TimeSpan.MinValue bis reichen TimeSpan.MaxValue.

Instanziieren eines TimeSpan-Werts

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

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

    TimeSpan interval = new TimeSpan();
    Console.WriteLine(interval.Equals(TimeSpan.Zero));    // Displays "True".
    
    let interval = TimeSpan()
    printfn $"{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 TimeSpan Wert auf eine angegebene Anzahl von Stunden, Minuten und Sekunden initialisiert.

    TimeSpan interval = new TimeSpan(2, 14, 18);
    Console.WriteLine(interval.ToString());              
    
    // Displays "02:14:18".
    
    let interval = TimeSpan(2, 14, 18)
    printfn $"{interval}"              
    
    // Displays "02:14:18".
    
    Dim interval As New TimeSpan(2, 14, 18)
    Console.WriteLine(interval.ToString())                ' Displays "02:14:18".
    
  • Indem Sie eine Methode aufrufen oder einen Vorgang ausführen, der einen TimeSpan Wert zurückgibt. Sie können beispielsweise einen TimeSpan Wert instanziieren, der das Intervall zwischen zwei Datums- und Uhrzeitwerten darstellt, wie das folgende Beispiel zeigt.

    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
    
    let departure = DateTime(2010, 6, 12, 18, 32, 0)
    let arrival = DateTime(2010, 6, 13, 22, 47, 0)
    let travelTime = arrival - departure  
    printfn $"{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 TimeSpan Objekt auch auf diese Weise mit einem Nullzeitwert initialisieren, wie das folgende Beispiel zeigt.

       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
    
    open System
    
    let rnd = Random()
    
    let getTimeBeforeLunch () =
        TimeSpan(rnd.Next(3, 6), 0, 0)
    
    let getTimeAfterLunch() =
        TimeSpan(rnd.Next(3, 6), 0, 0)
    
    do
        let timeSpent = TimeSpan.Zero
    
        let timeSpent = timeSpent + getTimeBeforeLunch ()
        let timeSpent = timeSpent + getTimeAfterLunch ()
    
        printfn $"Total time: {timeSpent}"
    
    
    // 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 DateTimeStrukturen , DateTimeOffsetund TimeSpan zurückgegeben.

  • Durch Analysieren der Zeichenfolgendarstellung eines TimeSpan Werts. Sie können die Parse Methoden und TryParse verwenden, um Zeichenfolgen, die Zeitintervalle enthalten, in Werte zu TimeSpan konvertieren. Im folgenden Beispiel wird die Parse -Methode verwendet, um ein Array von Zeichenfolgen in Werte zu TimeSpan 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'
    
    let values = [| "12"; "31."; "5.8:32:16"; "12:12:15.95"; ".12" |]
    for value in values do
        try
            let ts = TimeSpan.Parse value
            printfn $"'{value}' --> {ts}"
        with 
        | :? FormatException ->
            printfn $"Unable to parse '{value}'"
        | :? OverflowException ->
            printfn $"'{value}' is outside the range of a TimeSpan."
    
    // 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 TimeSpan Wert konvertiert werden soll, indem Sie die ParseExact -Methode oder TryParseExact aufrufen.

Ausführen von Vorgängen mit TimeSpan-Werten

Sie können Zeitdauern hinzufügen und subtrahieren, indem Sie die Addition Operatoren und verwenden Subtraction oder die Add Methoden und Subtract aufrufen. Sie können auch zwei Zeitdauern vergleichen, indem Sie die CompareMethoden , CompareTound Equals aufrufen. Die TimeSpan Struktur enthält auch die Duration Methoden und Negate , mit denen Zeitintervalle in positive und negative Werte konvertiert werden.

Der Wertebereich TimeSpan beträgt MinValueMaxValue.

Formatieren eines TimeSpan-Werts

Ein TimeSpan Wert kann als [-]d dargestellt werden. hh:mm:ss. ff, wobei das optionale Minuszeichen ein negatives Zeitintervall angibt, ist die d-Komponente Tage, hh ist Stunden, gemessen auf einer 24-Stunden-Uhr, mm ist Minuten, ss ist Sekunden und ff ist Bruchteile einer Sekunde. 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 TimeSpan Struktur kultursensitive Formatierungen über die Überladungen ihrer ToString Methode, die einen TimeSpan Wert in seine Zeichenfolgendarstellung konvertiert. Die Standardmethode TimeSpan.ToString() gibt ein Zeitintervall zurück, indem ein invariantes Format verwendet wird, das mit dem Rückgabewert in früheren Versionen des .NET Framework identisch ist. Mit TimeSpan.ToString(String) der Überladung können Sie eine Formatzeichenfolge angeben, die die Zeichenfolgendarstellung des Zeitintervalls definiert. Mit TimeSpan.ToString(String, IFormatProvider) der Überladung können Sie eine Formatzeichenfolge und die Kultur angeben, deren Formatierungskonventionen zum Erstellen der Zeichenfolgendarstellung des Zeitintervalls verwendet werden. TimeSpan unterstützt sowohl Standard- als auch benutzerdefinierte Formatzeichenfolgen. (Weitere Informationen finden Sie unter Standard-TimeSpan-Formatzeichenfolgen und benutzerdefinierte TimeSpan-Formatzeichenfolgen.) Allerdings sind nur Standardformatzeichenfolgen kulturabhängig.

Wiederherstellen der älteren TimeSpan-Formatierung

In einigen Fällen schlägt Code, der Werte in .NET Framework 3.5 und früheren Versionen erfolgreich formatiertTimeSpan, in .NET Framework 4 fehl. Dies tritt am häufigsten in Code auf, der eine <TimeSpan_LegacyFormatMode-Elementmethode> aufruft, um einen TimeSpan Wert mit einer Formatzeichenfolge zu formatieren. Das folgende Beispiel formatiert einen TimeSpan Wert erfolgreich in .NET Framework 3.5 und früheren Versionen, löst jedoch eine Ausnahme in .NET Framework 4 und höheren Versionen aus. Beachten Sie, dass versucht wird, einen TimeSpan Wert mithilfe eines nicht unterstützten Formatbezeichners zu formatieren, der in .NET Framework 3.5 und früheren Versionen 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);
   }
}
let showFormattingCode () =
    let interval = TimeSpan(12, 30, 45)
    try
        $"{interval:r}"
    with :? FormatException ->
        "Invalid Format"
    |> printfn "%s"

let showParsingCode () =
    let value = "000000006"
    try
        let interval = TimeSpan.Parse value
        printfn $"{value} --> {interval}"
    with
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"

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

printfn "---"

showParsingCode ()
// Output:
//       000000006 --> 6.00:00:00
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 TimeSpan Werten auf eine der folgenden Arten wiederherstellen:

  • Erstellen Sie eine Konfigurationsdatei, die das <TimeSpan_LegacyFormatMode-Element> enthält. Das Festlegen des Attributs enabled dieses Elements auf die true Wiederherstellung der Legacyformatierung TimeSpan auf Anwendungsbasis.

  • Durch Festlegen des Kompatibilitätsschalters "NetFx40_TimeSpanLegacyFormatMode", wenn Sie eine Anwendungsdomäne erstellen. Dies ermöglicht die Legacyformatierung TimeSpan auf Anwendungsdomänenbasis. Im folgenden Beispiel wird eine Anwendungsdomäne erstellt, die Legacyformatierung TimeSpan 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");
       }
    }
    
    open System
    
    let appSetup = AppDomainSetup()
    appSetup.SetCompatibilitySwitches [| "NetFx40_TimeSpanLegacyFormatMode" |]
    let legacyDomain = AppDomain.CreateDomain("legacyDomain", null, appSetup)
    legacyDomain.ExecuteAssembly "ShowTimeSpan.exe" |> ignore
    
    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 Alte TimeSpan Formatierungsverhalten wiederhergestellt.

    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.
    
    open System
    
    let interval = DateTime.Now - DateTime.Now.Date
    printfn $"Elapsed Time Today: {interval:d} hours."
    // 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(Int32, 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.

NanosecondsPerTick

Stellt die Anzahl der Nanosekunden pro Tick dar. Dieses Feld ist konstant.

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.

TicksPerMicrosecond

Stellt die Anzahl der Teilstriche in 1 Mikrosekunde 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.

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 Zeitintervalls ab, das durch die aktuelle TimeSpan-Struktur dargestellt wird.

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

TotalMicroseconds

Ruft den Wert der aktuellen TimeSpan Struktur ab, ausgedrückt in ganzen mikrosekunden und Bruchteilen.

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.

TotalNanoseconds

Ruft den Wert der aktuellen TimeSpan Struktur ab, ausgedrückt in ganzen und Bruchteilen von Nanosekunden.

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

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.

FromMicroseconds(Double)

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

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