TimeSpan Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Stellt ein Zeitintervall dar.

public value class 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>

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

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

Vererbung

Object

ValueType

TimeSpan

Implementiert

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

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 verknüpft ist. 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 Bezug auf einen bestimmten Start- 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 aus Gründen der 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 der Teilstriche, die dem dargestellten Zeitintervall entsprechen. Ein Tick entspricht 100 Nanosekunden oder einer Zehnmillionstelsekunde einer 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".
  

• Durch Aufrufen einer Methode oder Ausführen eines Vorgangs, der einen TimeSpan Wert zurückgibt. Sie können beispielsweise einen TimeSpan Wert instanziieren, der das Intervall zwischen zwei Datums- und Uhrzeitwerten darstellt, wie 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
  

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

  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 - oder TryParseExact -Methode aufrufen.

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

Sie können Zeitdauern hinzufügen und subtrahieren, indem Sie entweder 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 -Methode und Negate die -Methode, die Zeitintervalle in positive und negative Werte konvertieren.

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, ist die d-Komponente Tage, hh ist Stunden, wie auf einer 24-Stunden-Uhr gemessen, 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 kulturabhängige Formatierungen durch 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 der .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 ist am häufigsten in Code, der eine <TimeSpan_LegacyFormatMode-Elementmethode> aufruft, um einen TimeSpan Wert mit einer Formatzeichenfolge zu formatieren. Im folgenden Beispiel wird ein TimeSpan Wert in .NET Framework 3.5 und früheren Versionen erfolgreich formatiert, es wird jedoch eine Ausnahme in .NET Framework 4 und höheren Versionen ausgelöst. Beachten Sie, dass versucht wird, einen TimeSpan Wert mithilfe eines nicht unterstützten Formatbezeichners zu formatieren, der in .NET Framework Version 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:

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

• Durch Festlegen des Kompatibilitätsschalters "NetFx40_TimeSpanLegacyFormatMode" beim Erstellen einer Anwendungsdomäne. 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 auf das alte TimeSpan Formatierungsverhalten zurückgesetzt.

  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 auf eine angegebene Anzahl von Tagen, Stunden, Minuten, Sekunden, Millisekunden und Mikrosekunden.
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.

Weitere Informationen

• DateTime
• DateTimeOffset
• Calendar