System.TimeSpan-structuur

2025-03-26

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

Een TimeSpan object vertegenwoordigt een tijdsinterval (duur van tijd of verstreken tijd) dat wordt gemeten als een positief of negatief aantal dagen, uren, minuten, seconden en breuken van een seconde. De TimeSpan structuur kan ook worden gebruikt om het tijdstip van de dag weer te geven, maar alleen als de tijd niet is gerelateerd aan een bepaalde datum. Anders moet de DateTime of DateTimeOffset structuur worden gebruikt. (Zie TimeSpanvoor meer informatie over het gebruik van de structuur om de tijd van de dag weer te geven.)

Notitie

Een TimeSpan waarde vertegenwoordigt een tijdsinterval en kan worden uitgedrukt als een bepaald aantal dagen, uren, minuten, seconden en milliseconden. Omdat het een algemeen interval vertegenwoordigt zonder verwijzing naar een bepaald begin- of eindpunt, kan het niet worden uitgedrukt in termen van jaren en maanden, die beide een variabel aantal dagen hebben. Het verschilt van een DateTime waarde, die een datum en tijd vertegenwoordigt zonder verwijzing naar een bepaalde tijdzone, of een DateTimeOffset waarde, die een specifiek tijdstip aangeeft.

De grootste tijdseenheid die door de TimeSpan structuur wordt gebruikt om de duur te meten, is een dag. Tijdsintervallen worden gemeten in dagen voor consistentie, omdat het aantal dagen in grotere tijdseenheden, zoals maanden en jaren, varieert.

De waarde van een TimeSpan object is het aantal tikken dat gelijk is aan het vertegenwoordigde tijdsinterval. Een tik is gelijk aan 100 nanoseconden, ofwel één tien miljoenste van een seconde. De waarde van een TimeSpan-object kan variëren van TimeSpan.MinValue tot TimeSpan.MaxValue.

Een TimeSpan-waarde instantiëren

U kunt een TimeSpan waarde op verschillende manieren instantiëren:

Door de impliciete parameterloze constructor aan te roepen. Hiermee maakt u een object waarvan de waarde TimeSpan.Zerois, zoals in het volgende voorbeeld wordt weergegeven.

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

Door een van de expliciete constructors aan te roepen. In het volgende voorbeeld wordt een TimeSpan waarde geïnitialiseerd tot een opgegeven aantal uren, minuten en seconden.

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

Door een methode aan te roepen of een bewerking uit te voeren die een TimeSpan waarde retourneert. U kunt bijvoorbeeld een instantie maken van een TimeSpan-waarde die het interval tussen twee datum- en tijdwaarden aangeeft, zoals in het volgende voorbeeld wordt weergegeven.

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($"{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

U kunt op deze manier ook een TimeSpan object initialiseren naar een nultijdwaarde, zoals in het volgende voorbeeld wordt weergegeven.

Random rnd = new Random();

TimeSpan timeSpent = TimeSpan.Zero;

timeSpent += GetTimeBeforeLunch();
timeSpent += GetTimeAfterLunch();

Console.WriteLine($"Total time: {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 waarden worden geretourneerd door rekenkundige operatoren en methoden van de DateTime, DateTimeOffseten TimeSpan structuren.

Door de tekenreeksweergave van een TimeSpan waarde te parseren. U kunt de methoden Parse en TryParse gebruiken om tekenreeksen met tijdsintervallen te converteren naar TimeSpan waarden. In het volgende voorbeeld wordt de methode Parse gebruikt om een matrix met tekenreeksen te converteren naar TimeSpan waarden.

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($"'{value}' --> {ts}");
   }
   catch (FormatException) {
      Console.WriteLine($"Unable to parse '{value}'");
   }
   catch (OverflowException) {
      Console.WriteLine($"'{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'

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'

Daarnaast kunt u de exacte indeling van de invoertekenreeks definiëren die moet worden geparseerd en geconverteerd naar een TimeSpan waarde door de methode ParseExact of TryParseExact aan te roepen.

Bewerkingen uitvoeren op TimeSpan-waarden

U kunt tijdsduur optellen en aftrekken met behulp van de operatoren Addition en Subtraction, of door de methoden Add en Subtract aan te roepen. U kunt ook twee tijdsduur vergelijken door de Compare, CompareToen Equals methoden aan te roepen. De TimeSpan structuur bevat ook de Duration- en Negate methoden, waarmee tijdsintervallen worden geconverteerd naar positieve en negatieve waarden,

Het bereik van TimeSpan waarden is van MinValue tot MaxValue.

Een tijdspannewaarde opmaken

Een TimeSpan waarde kan worden weergegeven als [-]d.uu:mm:ss.ff, waarbij het optionele minteken een negatief tijdsinterval aangeeft, het d onderdeel dagen is, uu uren is zoals gemeten op een klok van 24 uur, mm minuten is, seconden is en ff fracties van een seconde is. Dat wil gezegd, een tijdsinterval bestaat uit een positief of negatief aantal dagen zonder een tijdstip van de dag, of een aantal dagen met een tijd van de dag, of alleen een tijdstip van de dag.

Vanaf .NET Framework 4 ondersteunt de TimeSpan structuur cultuurgevoelige opmaak door de overbelasting van de ToString methode, waarmee een TimeSpan waarde wordt geconverteerd naar de tekenreeksweergave. De standaardmethode TimeSpan.ToString() retourneert een tijdsinterval met behulp van een invariante indeling die identiek is aan de retourwaarde in eerdere versies van .NET Framework. Met TimeSpan.ToString(String)-overload kunt u een indelingsreeks opgeven die de tekenreeksrepresentatie van het tijdsinterval definieert. Met de TimeSpan.ToString(String, IFormatProvider) overload kunt u een notatiereeks en de cultuur specificeren waarvan de opmaakconventies worden gebruikt om de tekenreeksweergave van het tijdsinterval te maken. TimeSpan ondersteunt tekenreeksen met standaard- en aangepaste indelingen. (Zie Standard TimeSpan Format Strings en Custom TimeSpan Format Stringsvoor meer informatie. Alleen tekenreeksen met standaardindeling zijn echter cultuurgevoelig.

Verouderde TimeSpan-opmaak herstellen

In sommige gevallen werkt code die TimeSpan-waarden succesvol opmaakt in .NET Framework 3.5 en eerdere versies niet in .NET Framework 4. Dit komt het meest voor in code die een <TimeSpan_LegacyFormatMode> element de methode aanroept om een TimeSpan waarde te formatteren met een notatietekenreeks. In het volgende voorbeeld wordt een TimeSpan-waarde correct opgemaakt in .NET Framework 3.5 en eerdere versies, maar wordt een uitzondering gegenereerd in .NET Framework 4 en latere versies. Houd er rekening mee dat er wordt geprobeerd een TimeSpan-waarde op te maken met behulp van een niet-ondersteunde indelingsaanduiding, die wordt genegeerd in .NET Framework 3.5 en eerdere versies.

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($"{value} --> {interval}");
    }
    catch (FormatException)
    {
        Console.WriteLine($"{value}: Bad Format");
    }
    catch (OverflowException)
    {
        Console.WriteLine($"{value}: Overflow");
    }
}

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

Als u de code niet kunt wijzigen, kunt u de verouderde opmaak van TimeSpan waarden op een van de volgende manieren herstellen:

Door een configuratiebestand op te stellen dat het element <TimeSpan_LegacyFormatMode>bevat. Als u het enabled kenmerk van dit element instelt op true wordt verouderde TimeSpan opmaak per toepassing hersteld.

Door de compatibiliteitsswitch 'NetFx40_TimeSpanLegacyFormatMode' in te stellen wanneer u een toepassingsdomein maakt. Dit maakt verouderde TimeSpan opmaak mogelijk per toepassingsdomein. In het volgende voorbeeld wordt een toepassingsdomein gemaakt dat gebruikmaakt van verouderde TimeSpan opmaak.

using System;

public class Example2
{
    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 Example3
    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

Wanneer de volgende code wordt uitgevoerd in het nieuwe toepassingsdomein, wordt het verouderde TimeSpan opmaakgedrag hersteld.

using System;

public class Example3
{
   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 Example4
    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.

Delen via

System.TimeSpan-structuur

Een TimeSpan-waarde instantiëren

Bewerkingen uitvoeren op TimeSpan-waarden

Een tijdspannewaarde opmaken

Verouderde TimeSpan-opmaak herstellen

Aanvullende resources