TimeSpan Struktura

Definice

Představuje časový interval.

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)
Dědičnost
TimeSpan
Atributy
Implementuje

Příklady

Následující příklad vytvoří instanci objektu TimeSpan , který představuje rozdíl mezi dvěma kalendářními daty. Potom zobrazí vlastnosti objektu TimeSpan .

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

Poznámky

Objekt TimeSpan představuje časový interval (dobu trvání nebo uplynulý čas), který se měří jako kladný nebo záporný počet dnů, hodin, minut, sekund a zlomků sekundy. Strukturu TimeSpan lze také použít k reprezentaci denního času, ale pouze v případě, že čas nesouvisí s konkrétním datem. V opačném případě by se místo toho DateTime měla použít struktura nebo DateTimeOffset . (Další informace o použití TimeSpan struktury k vyjádření denního času najdete v tématu Volba mezi datem a časem, datetimeoffset, timespan a TimeZoneInfo.)

Poznámka

Hodnota TimeSpan představuje časový interval a může být vyjádřena určitým počtem dnů, hodin, minut, sekund a milisekund. Vzhledem k tomu, že představuje obecný interval bez odkazu na konkrétní počáteční nebo koncový bod, nelze jej vyjádřit v letech a měsících, z nichž oba mají proměnlivý počet dnů. Liší se od DateTime hodnoty, která představuje datum a čas bez odkazu na konkrétní časové pásmo, nebo DateTimeOffset hodnotu, která představuje konkrétní časový okamžik.

Největší jednotkou času, kterou TimeSpan struktura používá k měření doby trvání, je den. Časové intervaly se z důvodu konzistence měří ve dnech, protože počet dnů ve větších časových jednotkách, jako jsou měsíce a roky, se liší.

Hodnota objektu TimeSpan je počet zaškrtnutých hodnot, které se rovnají reprezentovaným časovým intervalům. Klíště se rovná 100 nanosekund nebo jedné desetimiliontě sekundy. Hodnota objektu může být v rozsahu TimeSpan od TimeSpan.MinValue do TimeSpan.MaxValue.

Vytvoření instance hodnoty TimeSpan

Vytvořit instanci TimeSpan hodnoty můžete několika způsoby:

  • Voláním implicitního konstruktoru bez parametrů. Tím se vytvoří objekt, jehož hodnota je TimeSpan.Zero, jak ukazuje následující příklad.

    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".
    
  • Voláním jednoho z jeho explicitních konstruktorů. Následující příklad inicializuje TimeSpan hodnotu na zadaný počet hodin, minut a sekund.

    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".
    
  • Voláním metody nebo provedením operace, která vrací TimeSpan hodnotu. Můžete například vytvořit TimeSpan instanci hodnoty, která představuje interval mezi dvěma hodnotami data a času, jak ukazuje následující příklad.

    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
    

    Tímto způsobem můžete také inicializovat TimeSpan objekt na nulovou časovou hodnotu, jak ukazuje následující příklad.

       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 hodnoty jsou vráceny aritmetické operátory a metody DateTimestruktur , DateTimeOffseta TimeSpan .

  • Parsováním řetězcové reprezentace TimeSpan hodnoty. Pomocí metod a TryParse můžete Parse převést řetězce obsahující časové intervaly na TimeSpan hodnoty. Následující příklad používá metodu Parse k převodu pole řetězců na TimeSpan hodnoty.

    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'
    

    Kromě toho můžete definovat přesný formát vstupního řetězce, který se má analyzovat a převést na TimeSpan hodnotu voláním ParseExact metody nebo TryParseExact .

Provádění operací na hodnotách TimeSpan

Dobu trvání můžete sčítat a odčítat buď pomocí Addition operátorů a Subtraction , nebo voláním Add metod a Subtract . Můžete také porovnat dvě doby trvání voláním Comparemetod , CompareToa Equals . Struktura TimeSpan zahrnuje Duration také metody a Negate , které převádějí časové intervaly na kladné a záporné hodnoty.

Rozsah TimeSpan hodnot je MinValue na MaxValue.

Formátování hodnoty TimeSpan

Hodnota TimeSpan může být reprezentována jako [-]d. hh:mm:ss. ff, kde volitelné znaménko minus označuje záporný časový interval, komponenta d je dny, hh je hodiny měřené na 24hodinových hodinách, mm je minuty, ss sekundy a ff je zlomky sekundy. To znamená, že časový interval se skládá z kladného nebo záporného počtu dnů bez denního času nebo počtu dnů s denním časem nebo pouze denního času.

Počínaje rozhraním .NET Framework 4 TimeSpan podporuje struktura formátování citlivé na jazykovou verzi prostřednictvím přetížení své ToString metody, která převádí TimeSpan hodnotu na řetězcovou reprezentaci. Výchozí TimeSpan.ToString() metoda vrátí časový interval pomocí invariantního formátu, který je identický s jeho návratovou hodnotou v předchozích verzích rozhraní .NET Framework. Přetížení TimeSpan.ToString(String) umožňuje zadat formátovací řetězec, který definuje řetězcovou reprezentaci časového intervalu. Přetížení TimeSpan.ToString(String, IFormatProvider) umožňuje určit formátovací řetězec a jazykovou verzi, jejíž konvence formátování se používají k vytvoření řetězcové reprezentace časového intervalu. TimeSpan podporuje standardní i vlastní formátovací řetězce. (Další informace najdete v tématech Standardní řetězce formátu TimeSpan a Vlastní řetězce formátu TimeSpan.) Pouze řetězce standardního formátu jsou však citlivé na jazykovou verzi.

Obnovení staršího formátování TimeSpan

V některých případech kód, který úspěšně formátuje TimeSpan hodnoty v rozhraní .NET Framework 3.5 a starších verzích, selže v rozhraní .NET Framework 4. To je nejběžnější v kódu, který volá metodu elementu< TimeSpan_LegacyFormatMode> pro formátování TimeSpan hodnoty pomocí řetězce formátu. Následující příklad úspěšně formátuje TimeSpan hodnotu v rozhraní .NET Framework 3.5 a starších verzích, ale vyvolá výjimku v rozhraní .NET Framework 4 a novějších verzích. Všimněte si, že se pokouší formátovat TimeSpan hodnotu pomocí nepodporovaného specifikátoru formátu, který je ignorován v rozhraní .NET Framework 3.5 a starších verzích.

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

Pokud kód nemůžete upravit, můžete obnovit starší formátování TimeSpan hodnot jedním z následujících způsobů:

  • Vytvořením konfiguračního souboru, který obsahuje <element TimeSpan_LegacyFormatMode>. Nastavení atributu enabled tohoto elementu na true obnovení staršího TimeSpan formátování pro jednotlivé aplikace.

  • Nastavením přepínače kompatibility "NetFx40_TimeSpanLegacyFormatMode" při vytváření domény aplikace. To umožňuje starší TimeSpan formátování pro jednotlivé domény aplikace. Následující příklad vytvoří doménu aplikace, která používá starší TimeSpan formátování.

    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
    

    Když se následující kód spustí v nové doméně aplikace, vrátí se k chování starší verze TimeSpan formátování.

    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.
    

Konstruktory

TimeSpan(Int32, Int32, Int32)

Inicializuje novou instanci TimeSpan struktury na zadaný počet hodin, minut a sekund.

TimeSpan(Int32, Int32, Int32, Int32)

Inicializuje novou instanci TimeSpan struktury na zadaný počet dní, hodin, minut a sekund.

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

Inicializuje novou instanci TimeSpan struktury na zadaný počet dní, hodin, minut, sekund a milisekund.

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

Inicializuje novou instanci TimeSpan struktury na zadaný počet dní, hodin, minut, sekund, milisekund a mikrosekund.

TimeSpan(Int64)

Inicializuje novou instanci TimeSpan struktury na zadaný počet značek.

Pole

MaxValue

Představuje maximální TimeSpan hodnotu. Toto pole je jen ke čtení.

MinValue

Představuje minimální TimeSpan hodnotu. Toto pole je jen ke čtení.

NanosecondsPerTick

Představuje počet nanosekund na tick. Toto pole je konstantní.

TicksPerDay

Představuje počet značek za 1 den. Toto pole je konstantní.

TicksPerHour

Představuje počet značek za 1 hodinu. Toto pole je konstantní.

TicksPerMicrosecond

Představuje počet značek za 1 mikrosekundu. Toto pole je konstantní.

TicksPerMillisecond

Představuje počet značek v milisekundách. Toto pole je konstantní.

TicksPerMinute

Představuje počet značek za 1 minutu. Toto pole je konstantní.

TicksPerSecond

Představuje počet značek za 1 sekundu.

Zero

Představuje nulovou TimeSpan hodnotu. Toto pole je jen ke čtení.

Vlastnosti

Days

Získá dny součást časového intervalu reprezentované aktuální TimeSpan struktury.

Hours

Získá komponentu hodin časového intervalu reprezentované aktuální TimeSpan strukturou.

Microseconds

Získá mikrosekundy součást časového intervalu reprezentované aktuální TimeSpan struktury.

Milliseconds

Získá komponentu milisekund časového intervalu reprezentované aktuální TimeSpan strukturou.

Minutes

Získá minutovou součást časového intervalu reprezentované aktuální TimeSpan strukturou.

Nanoseconds

Získá nanosekundy součást časového intervalu reprezentované aktuální TimeSpan strukturou.

Seconds

Získá sekundovou součást časového intervalu reprezentované aktuální TimeSpan strukturou.

Ticks

Získá počet značek, které představují hodnotu aktuální TimeSpan struktury.

TotalDays

Získá hodnotu aktuální TimeSpan struktury vyjádřenou v celých a zlomkové dny.

TotalHours

Získá hodnotu aktuální TimeSpan struktury vyjádřené v celých a desetinných hodinách.

TotalMicroseconds

Získá hodnotu aktuální TimeSpan struktury vyjádřené v celých a desetinných mikrosekundách.

TotalMilliseconds

Získá hodnotu aktuální TimeSpan struktury vyjádřené v celých a desetinných milisekundách.

TotalMinutes

Získá hodnotu aktuální TimeSpan struktury vyjádřenou v celých minutách a zlomku.

TotalNanoseconds

Získá hodnotu aktuální TimeSpan struktury vyjádřené v celých a zlomcích nanosekundy.

TotalSeconds

Získá hodnotu aktuální TimeSpan struktury vyjádřenou v celých a zlomkových sekundách.

Metody

Add(TimeSpan)

Vrátí nový TimeSpan objekt, jehož hodnota je součet zadaného TimeSpan objektu a této instance.

Compare(TimeSpan, TimeSpan)

Porovná dvě TimeSpan hodnoty a vrátí celé číslo, které označuje, zda je první hodnota kratší, rovna nebo delší než druhá hodnota.

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které označuje, zda je tato instance kratší, rovna nebo delší než zadaný objekt.

CompareTo(TimeSpan)

Porovná tuto instanci se zadaným TimeSpan objektem a vrátí celé číslo, které označuje, zda je tato instance kratší než, rovna nebo delší než TimeSpan objekt.

Divide(Double)

Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem dělení této instance a zadaného divisorobjektu .

Divide(TimeSpan)

Vrátí novou Double hodnotu, která je výsledkem dělení této instance a zadané tshodnoty .

Duration()

Vrátí nový TimeSpan objekt, jehož hodnota je absolutní hodnotou aktuálního TimeSpan objektu.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

Equals(TimeSpan)

Vrátí hodnotu označující, zda se tato instance rovná zadanému TimeSpan objektu.

Equals(TimeSpan, TimeSpan)

Vrátí hodnotu, která označuje, zda jsou dvě zadané instance rovny TimeSpan .

FromDays(Double)

Vrátí hodnotu TimeSpan , která představuje zadaný počet dní, kde je specifikace přesná na nejbližší milisekundu.

FromHours(Double)

Vrátí hodnotu TimeSpan , která představuje zadaný počet hodin, kde je specifikace přesná na nejbližší milisekundu.

FromMicroseconds(Double)

Vrátí hodnotu TimeSpan , která představuje zadaný počet mikrosekund.

FromMilliseconds(Double)

Vrátí hodnotu TimeSpan , která představuje zadaný počet milisekund.

FromMinutes(Double)

Vrátí hodnotu TimeSpan , která představuje zadaný počet minut, kde je specifikace přesná na nejbližší milisekundu.

FromSeconds(Double)

Vrátí hodnotu , TimeSpan která představuje zadaný počet sekund, kde je specifikace přesná na nejbližší milisekundu.

FromTicks(Int64)

Vrátí hodnotu TimeSpan , která představuje zadaný čas, kde je specifikace v jednotkách zaškrtnutí.

GetHashCode()

Vrátí kód hash pro tuto instanci.

Multiply(Double)

Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem násobení této instance a zadaného factorobjektu .

Negate()

Vrátí nový TimeSpan objekt, jehož hodnota je negovaná hodnota této instance.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Převede reprezentaci rozsahu časového intervalu na jeho TimeSpan ekvivalent pomocí informací o formátu specifickém pro zadanou jazykovou verzi.

Parse(String)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent.

Parse(String, IFormatProvider)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí informací o formátu specifickém pro zadanou jazykovou verzi.

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

Převede rozsah znaků časového intervalu na ekvivalent TimeSpan pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

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

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných formátů, informací o formátu specifického pro jazykovou verzi a stylů. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

ParseExact(String, String, IFormatProvider)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Převede řetězcovou reprezentaci časového intervalu na ekvivalent TimeSpan pomocí zadaného formátu, informací o formátu specifického pro jazykovou verzi a stylů. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

ParseExact(String, String[], IFormatProvider)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného pole formátovací řetězce a informace o formátu specifické pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

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

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných formátů, informací o formátu specifického pro jazykovou verzi a stylů. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

Subtract(TimeSpan)

Vrátí nový TimeSpan objekt, jehož hodnota je rozdíl mezi zadaným TimeSpan objektem a touto instancí.

ToString()

Převede hodnotu aktuálního TimeSpan objektu na ekvivalentní řetězcovou reprezentaci.

ToString(String)

Převede hodnotu aktuálního TimeSpan objektu na ekvivalentní řetězcovou reprezentaci pomocí zadaného formátu.

ToString(String, IFormatProvider)

Převede hodnotu aktuálního TimeSpan objektu na ekvivalentní řetězcovou reprezentaci pomocí zadaného formátu a informací o formátování specifické pro jazykovou verzi.

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

Pokusí se formátovat hodnotu aktuálního časového rozsahu číslo instance do zadaného rozsahu znaků.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Převede reprezentaci rozsahu časového intervalu na ekvivalent TimeSpan pomocí informací o formátování specifické pro konkrétní jazykovou verzi a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Převede reprezentaci rozsahu časového intervalu na jeho TimeSpan ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.

TryParse(String, IFormatProvider, TimeSpan)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadané informace formátování specifické pro jazykovou verzi a vrátí hodnotu, která označuje, zda převod proběhl úspěšně.

TryParse(String, TimeSpan)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.

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

Převede zadanou reprezentaci rozsahu časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

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

Převede zadanou reprezentaci rozsahu časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného formátu, informací o formátu specifické pro jazykovou verzi a stylů a vrátí hodnotu, která označuje, zda byl převod úspěšný. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

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

Převede zadanou reprezentaci rozsahu časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných formátů a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

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

Převede zadanou reprezentaci rozsahu časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných formátů, informací o formátu specifické pro jazykovou verzi a stylů. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

TryParseExact(String, String, IFormatProvider, TimeSpan)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

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

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného formátu, informací o formátu a stylů specifických pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat určenému formátu.

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

Převede zadanou řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných formátů a informací o formátu specifickém pro jazykovou verzi. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

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

Převede zadanou řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných formátů, informací o formátu specifické pro jazykovou verzi a stylů. Formát řetězcového vyjádření musí přesně odpovídat jednomu z určených formátů.

Operátory

Addition(TimeSpan, TimeSpan)

Přidá dvě zadané TimeSpan instance.

Division(TimeSpan, Double)

Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem dělení timeSpan instance a zadané divisorhodnoty .

Division(TimeSpan, TimeSpan)

Vrátí novou Double hodnotu, která je výsledkem dělení t1 instance a zadané t2hodnoty .

Equality(TimeSpan, TimeSpan)

Určuje, zda jsou dvě TimeSpan instance stejné.

GreaterThan(TimeSpan, TimeSpan)

Určuje, zda je zadaná TimeSpan hodnota větší než jiná zadaná TimeSpanhodnota .

GreaterThanOrEqual(TimeSpan, TimeSpan)

Určuje, zda je zadaná TimeSpan hodnota větší nebo rovna jiné zadané TimeSpanhodnotě .

Inequality(TimeSpan, TimeSpan)

Určuje, jestli si dvě TimeSpan instance nejsou rovny.

LessThan(TimeSpan, TimeSpan)

Určuje, zda je zadaná TimeSpan hodnota menší než jiná zadaná TimeSpanhodnota .

LessThanOrEqual(TimeSpan, TimeSpan)

Určuje, zda je zadaná TimeSpan hodnota menší nebo rovna jiné zadané TimeSpanhodnotě .

Multiply(Double, TimeSpan)

Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem vynásobení zadané factor a zadané timeSpan instance.

Multiply(TimeSpan, Double)

Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem vynásobení zadané timeSpan instance a zadané factorinstance .

Subtraction(TimeSpan, TimeSpan)

Odečte zadanou TimeSpan hodnotu od jiného zadaného TimeSpan.

UnaryNegation(TimeSpan)

Vrátí hodnotu, TimeSpan jejíž hodnota je negovanou hodnotou zadané instance.

UnaryPlus(TimeSpan)

Vrátí zadanou instanci .TimeSpan

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které označuje, zda je tato instance kratší, rovna nebo delší než zadaný objekt.

Platí pro

Viz také