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 : IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>, IAdditiveIdentity<TimeSpan, TimeSpan>, IComparable<TimeSpan>, IComparisonOperators<TimeSpan, TimeSpan>, IDivisionOperators<TimeSpan, double, TimeSpan>, IDivisionOperators<TimeSpan, TimeSpan, double>, IEqualityOperators<TimeSpan, TimeSpan>, IEquatable<TimeSpan>, IMinMaxValue<TimeSpan>, IMultiplicativeIdentity<TimeSpan, double>, IMultiplyOperators<TimeSpan, double, TimeSpan>, IParseable<TimeSpan>, ISpanFormattable, ISpanParseable<TimeSpan>, ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>, IUnaryNegationOperators<TimeSpan, TimeSpan>, IUnaryPlusOperators<TimeSpan, 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 : IAdditionOperators<TimeSpan,TimeSpan,TimeSpan>, IAdditiveIdentity<TimeSpan,TimeSpan>, IComparable<TimeSpan>, IComparisonOperators<TimeSpan,TimeSpan>, IDivisionOperators<TimeSpan,double,TimeSpan>, IDivisionOperators<TimeSpan,TimeSpan,double>, IEqualityOperators<TimeSpan,TimeSpan>, IEquatable<TimeSpan>, IMinMaxValue<TimeSpan>, IMultiplicativeIdentity<TimeSpan,double>, IMultiplyOperators<TimeSpan,double,TimeSpan>, IParseable<TimeSpan>, ISpanFormattable, ISpanParseable<TimeSpan>, ISubtractionOperators<TimeSpan,TimeSpan,TimeSpan>, IUnaryNegationOperators<TimeSpan,TimeSpan>, IUnaryPlusOperators<TimeSpan,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 ISpanFormattable
    interface IFormattable
    interface IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>
    interface IAdditiveIdentity<TimeSpan, TimeSpan>
    interface IComparisonOperators<TimeSpan, TimeSpan>
    interface IEqualityOperators<TimeSpan, TimeSpan>
    interface IDivisionOperators<TimeSpan, double, TimeSpan>
    interface IDivisionOperators<TimeSpan, TimeSpan, double>
    interface IMinMaxValue<TimeSpan>
    interface IMultiplyOperators<TimeSpan, double, TimeSpan>
    interface IMultiplicativeIdentity<TimeSpan, double>
    interface ISpanParseable<TimeSpan>
    interface IParseable<TimeSpan>
    interface ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>
    interface IUnaryNegationOperators<TimeSpan, TimeSpan>
    interface IUnaryPlusOperators<TimeSpan, 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 IAdditionOperators(Of TimeSpan, TimeSpan, TimeSpan), IAdditiveIdentity(Of TimeSpan, TimeSpan), IComparable(Of TimeSpan), IComparisonOperators(Of TimeSpan, TimeSpan), IDivisionOperators(Of TimeSpan, Double, TimeSpan), IDivisionOperators(Of TimeSpan, TimeSpan, Double), IEqualityOperators(Of TimeSpan, TimeSpan), IEquatable(Of TimeSpan), IMinMaxValue(Of TimeSpan), IMultiplicativeIdentity(Of TimeSpan, Double), IMultiplyOperators(Of TimeSpan, Double, TimeSpan), IParseable(Of TimeSpan), ISpanFormattable, ISpanParseable(Of TimeSpan), ISubtractionOperators(Of TimeSpan, TimeSpan, TimeSpan), IUnaryNegationOperators(Of TimeSpan, TimeSpan), IUnaryPlusOperators(Of TimeSpan, 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 TimeSpan objektu, který představuje rozdíl mezi dvěma kalendářními daty. Pak 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 (doba 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 použít také k reprezentaci času dne, ale pouze v případě, že čas nesouvisí s konkrétním datem. DateTime Jinak by se měla použít struktura nebo DateTimeOffset struktura. (Další informace o použití TimeSpan struktury k odrazu času dne najdete v tématu Výběr mezi datetimem, DateTimeOffset, TimeSpan a TimeZoneInfo.)

Poznámka

TimeSpan Hodnota představuje časový interval a dá se vyjádřit jako určitý počet 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ž obě 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 určitý moment času.

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

Hodnota objektu TimeSpan je počet záškrtů, které se rovná reprezentovaný časový interval. Klíště se rovná 100 nanosekund nebo deseti milionů sekund. Hodnota objektu může být v rozsahu TimeSpan od TimeSpan.MinValue do TimeSpan.MaxValue.

Vytvoření instance hodnoty TimeSpan

Hodnotu můžete vytvořit TimeSpan 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á vrátí 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
    

    Objekt můžete také inicializovat TimeSpan na nulovou časovou hodnotu tímto způsobem, 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 metodami DateTime, DateTimeOffseta TimeSpan struktury.

  • Parsováním řetězcové reprezentace TimeSpan hodnoty Pomocí metod a TryParse metod můžete Parse převést řetězce, které obsahují č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 metody.

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

Dobu trvání můžete sčítat a odčítat buď pomocí Addition operátorů, Subtraction nebo voláním Add a metod.Subtract Můžete také porovnat dvě doby trvání voláním Compare, CompareToa Equals metod. Struktura TimeSpan také obsahuje Duration a Negate metody, 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

Hodnotu TimeSpan lze reprezentovat jako [-]d.hh:mm:ss. ff, kde volitelný znaménko minus označuje záporný časový interval, d komponenta je dny, hh je hodiny měřené na 24hodinovém hodině, mm je minuty, ss je 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 čas dne.

Od .NET Framework 4 TimeSpan struktura podporuje formátování citlivé na jazykovou verzi prostřednictvím přetížení jeho ToString metody, která převede TimeSpan hodnotu na její řetězcovou reprezentaci. Výchozí TimeSpan.ToString() metoda vrátí časový interval pomocí invariantního formátu, který je identický s vrácenou hodnotou v předchozích verzích .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 zadat řetězec formátu 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ématu Standardní řetězce formátu TimeSpan a vlastní řetězce formátu TimeSpan.) Pouze standardní řetězce formátu jsou ale 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 .NET Framework 3.5 a starších verzích, selže v .NET Framework 4. To je nejběžnější v kódu, který volá metodu elementu<TimeSpan_LegacyFormatMode> k formátování TimeSpan hodnoty pomocí řetězce formátu. Následující příklad úspěšně formátuje TimeSpan hodnotu v .NET Framework 3.5 a starších verzích, ale vyvolá výjimku v .NET Framework 4 a novějších verzích. Všimněte si, že se pokusí formátovat TimeSpan hodnotu pomocí nepodporovaného specifikátoru formátu, který se ignoruje v .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 prvek<TimeSpan_LegacyFormatMode>. Nastavení atributu enabled tohoto prvku tak, aby true se obnovilo starší TimeSpan formátování na základě jednotlivých aplikací.

  • Nastavením přepínače kompatibility NetFx40_TimeSpanLegacyFormatMode při vytváření domény aplikace. To umožňuje starší TimeSpan formátování na základě domény pro jednotlivé 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 v nové doméně aplikace spustí následující kód, vrátí se ke staršímu TimeSpan chování 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í, hodiny, minuty, sekundy a milisekundy.

TimeSpan(Int64)

Inicializuje novou instanci TimeSpan struktury na zadaný počet záškrtů.

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

TicksPerDay

Představuje počet záškrtů za 1 den. Toto pole je konstantní.

TicksPerHour

Představuje počet záškrtů za 1 hodinu. Toto pole je konstantní.

TicksPerMillisecond

Představuje počet škrtů v milisekundách. Toto pole je konstantní.

TicksPerMinute

Představuje počet záškrtů za 1 minutu. Toto pole je konstantní.

TicksPerSecond

Představuje počet záškrtů za 1 sekundu.

Zero

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

Vlastnosti

Days

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

Hours

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

Milliseconds

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

Minutes

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

Seconds

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

Ticks

Získá počet záškrtů, které představují hodnotu aktuální TimeSpan struktury.

TotalDays

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

TotalHours

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

TotalMilliseconds

Získá hodnotu aktuální TimeSpan struktury vyjádřené v celé a zlomkové milisekundy.

TotalMinutes

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

TotalSeconds

Získá hodnotu aktuální TimeSpan struktury vyjádřené 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, jestli 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ší, rovna nebo delší než TimeSpan objekt.

Divide(Double)

Vrátí nový TimeSpan objekt, který 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é ts.

Duration()

Vrátí nový TimeSpan objekt, jehož hodnota je absolutní hodnota 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 je tato instance rovna zadanému TimeSpan objektu.

Equals(TimeSpan, TimeSpan)

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

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, kdy je specifikace přesná na nejbližší milisekundu.

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)

TimeSpan Vrátí hodnotu, která představuje zadaný čas, kdy je specifikace v jednotkách klíště.

GetHashCode()

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

Multiply(Double)

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

Negate()

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

Parse(ReadOnlySpan<Char>, IFormatProvider)

Převede reprezentaci časového intervalu na ekvivalent TimeSpan pomocí zadaných informací o formátu specifické pro jazykovou verzi.

Parse(String)

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

Parse(String, IFormatProvider)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných informací o formátu specifické pro 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 ekvivalent TimeSpan 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ů.

ParseExact(String, String, IFormatProvider)

Převede řetězcovou reprezentaci č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(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ém 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 ekvivalent TimeSpan pomocí zadaného pole formátových řetězců a informací 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 ekvivalent TimeSpan 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ů.

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ězcové vyjádření.

ToString(String)

Převede hodnotu aktuálního TimeSpan objektu na ekvivalentní řetězcové vyjádření pomocí zadaného formátu.

ToString(String, IFormatProvider)

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

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

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

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

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

TryParse(ReadOnlySpan<Char>, TimeSpan)

Převede reprezentaci časového intervalu na ekvivalent TimeSpan a vrátí hodnotu, která označuje, jestli převod proběhl úspěšně.

TryParse(String, IFormatProvider, TimeSpan)

Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných informací o 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 ekvivalent TimeSpan a vrátí hodnotu, která označuje, jestli převod proběhl úspěšně.

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

Převede zadanou reprezentaci č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.

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

Převede zadanou reprezentaci časového intervalu na ekvivalent TimeSpan pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylů a vrátí hodnotu, která označuje, jestli převod proběhl ú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 časového intervalu na ekvivalent TimeSpan pomocí zadaných formátů a informací 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ů.

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

Převede zadanou reprezentaci časového intervalu na ekvivalent TimeSpan pomocí zadaných formátů, informací a stylů formátů specifických 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, TimeSpan)

Převede řetězcovou reprezentaci č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.

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

Převede řetězcovou reprezentaci časového intervalu na ekvivalent TimeSpan pomocí zadaného formátu, informací a stylů formátu specifického 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 ekvivalent TimeSpan pomocí zadaných formátů a informací 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ů.

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

Převede zadanou řetězcovou reprezentaci časového intervalu na ekvivalent TimeSpan pomocí zadaných formátů, informací a stylů 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ů.

Operátory

Addition(TimeSpan, TimeSpan)

Přidá dvě zadané TimeSpan instance.

Division(TimeSpan, Double)

Vrátí nový TimeSpan objekt, který je výsledkem dělení timeSpan instance a zadaného divisorobjektu .

Division(TimeSpan, TimeSpan)

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

Equality(TimeSpan, TimeSpan)

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

GreaterThan(TimeSpan, TimeSpan)

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

GreaterThanOrEqual(TimeSpan, TimeSpan)

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

Inequality(TimeSpan, TimeSpan)

Určuje, jestli se dvě TimeSpan instance nerovnají.

LessThan(TimeSpan, TimeSpan)

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

LessThanOrEqual(TimeSpan, TimeSpan)

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

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ého factorobjektu .

Subtraction(TimeSpan, TimeSpan)

Odečte zadaný od jiného zadaného TimeSpan TimeSpanparametru .

UnaryNegation(TimeSpan)

TimeSpan Vrátí hodnotu, jejíž hodnotou je negated hodnota 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é