TimeSpan Struktura

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

TimeSpan.cs

Představuje časový interval.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

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

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

Dědičnost

Object

ValueType

TimeSpan

Implementuje

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

Příklady

Následující příklad vytvoří instanci objektu TimeSpan , který představuje rozdíl mezi dvěma kalendářními daty. 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í času nebo uplynulého času), který se měří jako kladný nebo záporný počet dní, hodin, minut, sekund a zlomků sekundy. Strukturu TimeSpan lze také použít k vyjádření času dne, ale pouze v případě, že čas nesouvisí s konkrétním datem. Jinak by se měla použít struktura DateTime nebo DateTimeOffset. (Další informace o použití struktury TimeSpan k zobrazení času dne naleznete v tématu Volba mezi DateTime, DateTimeOffset, TimeSpan a TimeZoneInfo.)

Note

Hodnota TimeSpan 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ž oba mají proměnlivý počet dnů. Liší se od hodnoty DateTime, která představuje datum a čas bez odkazu na konkrétní časové pásmo, nebo DateTimeOffset hodnotu, která představuje konkrétní okamžik času.

Největší časová jednotka, kterou struktura TimeSpan používá k měření doby trvání, 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 shodují s reprezentovaným časovým intervalem. Tik se rovná 100 nanosekundám nebo jedné desetimiliontině sekundy. Hodnota objektu TimeSpan může být v rozsahu od TimeSpan.MinValue po TimeSpan.MaxValue.

Vytvoření instance hodnoty TimeSpan

Hodnotu TimeSpan můžete instanciovat 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 hodnotu TimeSpan 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 instanci TimeSpan 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($"{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 inicializovat objekt TimeSpan 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: {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 MExample
      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
  

  Aritmetické operátory a metody struktur TimeSpan, DateTimea DateTimeOffset vrací TimeSpan hodnoty.

• Analýzou řetězcové reprezentace hodnoty TimeSpan. Pomocí metod Parse a TryParse můžete 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 hodnot.

  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'
  

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

Provádění operací s hodnotami TimeSpan

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

Rozsah hodnot TimeSpan je od MinValue do MaxValue.

Formátujte hodnotu TimeSpan

Hodnotu TimeSpan lze reprezentovat jako [-]d.hh:mm:ss.ff, kde volitelné znaménko minus označuje záporný časový interval, d komponenta jsou dny, hh jsou hodiny měřené ve 24hodinovém formátu, mm jsou minuty, ss jsou sekundy a ff jsou zlomky sekundy. To znamená, že časový interval se skládá z kladného nebo záporného počtu dnů bez času dne, nebo počtu dnů s časem dne nebo pouze času dne.

Struktura TimeSpan podporuje formátování citlivé na jazykovou verzi prostřednictvím přetížení jeho ToString metody, která převede hodnotu na řetězcovou TimeSpan reprezentaci. 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) vám umožňuje zadat formátovací řetězec a kulturu, 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 však citlivé na jazykovou verzi.

Konstruktory

Name	Description
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)	Inicializuje novou instanci TimeSpan struktury na zadaný počet dní, hodiny, minuty, sekundy, milisekundy a mikrosekundy.
TimeSpan(Int32, Int32, Int32, Int32, Int32)	Inicializuje novou instanci TimeSpan struktury na zadaný počet dní, hodiny, minuty, sekundy a milisekundy.
TimeSpan(Int32, Int32, Int32, Int32)	Inicializuje novou instanci TimeSpan struktury na zadaný počet dní, hodin, minut a sekund.
TimeSpan(Int32, Int32, Int32)	Inicializuje novou instanci TimeSpan struktury na zadaný počet hodin, minut a sekund.
TimeSpan(Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet záškrtů.

Pole

Name	Description
HoursPerDay	Představuje počet hodin za 1 den. Toto pole je konstantní.
MaxValue	Představuje maximální TimeSpan hodnotu. Toto pole je určeno pouze ke čtení.
MicrosecondsPerDay	Představuje počet mikrosekund za 1 den. Toto pole je konstantní.
MicrosecondsPerHour	Představuje počet mikrosekund za 1 hodinu. Toto pole je konstantní.
MicrosecondsPerMillisecond	Představuje počet mikrosekund v milisekundách. Toto pole je konstantní.
MicrosecondsPerMinute	Představuje počet mikrosekund za 1 minutu. Toto pole je konstantní.
MicrosecondsPerSecond	Představuje počet mikrosekund za 1 sekundu. Toto pole je konstantní.
MillisecondsPerDay	Představuje počet milisekund za 1 den. Toto pole je konstantní.
MillisecondsPerHour	Představuje počet milisekund za 1 hodinu. Toto pole je konstantní.
MillisecondsPerMinute	Představuje počet milisekund za 1 minutu. Toto pole je konstantní.
MillisecondsPerSecond	Představuje počet milisekund za 1 sekundu. Toto pole je konstantní.
MinutesPerDay	Představuje počet minut za 1 den. Toto pole je konstantní.
MinutesPerHour	Představuje počet minut za 1 hodinu. Toto pole je konstantní.
MinValue	Představuje minimální TimeSpan hodnotu. Toto pole je určeno pouze ke čtení.
NanosecondsPerTick	Představuje počet nanosekund na tick. Toto pole je konstantní.
SecondsPerDay	Představuje počet sekund za 1 den. Toto pole je konstantní.
SecondsPerHour	Představuje počet sekund za 1 hodinu. Toto pole je konstantní.
SecondsPerMinute	Představuje počet sekund za 1 minutu. Toto pole je konstantní.
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í.
TicksPerMicrosecond	Představuje počet tisek v 1 mikrosekundách. Toto pole je konstantní.
TicksPerMillisecond	Představuje počet odškrtávek 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 určeno pouze ke čtení.

Vlastnosti

Name	Description
Days	Získá dny součást časového intervalu reprezentované aktuální TimeSpan strukturou.
Hours	Získá komponentu hodin časového intervalu reprezentované aktuální TimeSpan strukturou.
Microseconds	Získá mikrosekundy komponentu časového intervalu reprezentované aktuální TimeSpan strukturou.
Milliseconds	Získá komponentu milisekund časového intervalu reprezentované aktuální TimeSpan strukturou.
Minutes	Získá komponentu minut časového intervalu reprezentované aktuální TimeSpan strukturou.
Nanoseconds	Získá nanosekundy 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.
TotalMicroseconds	Získá hodnotu aktuální TimeSpan struktury vyjádřené v celku a zlomkové mikrosekundy.
TotalMilliseconds	Získá hodnotu aktuální TimeSpan struktury vyjádřené v celém a zlomkovém milisekundách.
TotalMinutes	Získá hodnotu aktuální TimeSpan struktury vyjádřené v celých a desetinných minutách.
TotalNanoseconds	Získá hodnotu aktuální TimeSpan struktury vyjádřené v celku a zlomkové nanosekundy.
TotalSeconds	Získá hodnotu aktuální TimeSpan struktury vyjádřené v celých a desetinných sekundách.

Metody

Name	Description
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é urč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é urč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é určuje, zda je tato instance kratší, rovna nebo delší než TimeSpan objekt.
Divide(Double)	Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem dělení této instance zadaným divisor.
Divide(TimeSpan)	Vrátí novou Double hodnotu, která je výsledkem dělení této instance hodnotou ts.
Duration()	Vrátí nový TimeSpan objekt, jehož hodnotou je absolutní hodnota aktuálního TimeSpan objektu.
Equals(Object)	Vrátí hodnotu určující, zda je tato instance rovna zadanému objektu.
Equals(TimeSpan, TimeSpan)	Vrátí hodnotu, která určuje, zda jsou dvě zadané instance rovny TimeSpan .
Equals(TimeSpan)	Vrátí hodnotu určující, zda je tato instance rovna zadanému TimeSpan objektu.
FromDays(Double)	TimeSpan Vrátí hodnotu, která představuje zadaný počet dní, kde je specifikace přesná na nejbližší milisekundu.
FromDays(Int32, Int32, Int64, Int64, Int64, Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet dní, hodiny, minuty, sekundy, milisekundy a mikrosekundy.
FromDays(Int32)	Inicializuje novou instanci TimeSpan struktury na zadaný počet dní.
FromHours(Double)	TimeSpan Vrátí hodnotu, která představuje zadaný počet hodin, kde je specifikace přesná na nejbližší milisekundu.
FromHours(Int32, Int64, Int64, Int64, Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet hodin, minut, sekund, milisekund a mikrosekund.
FromHours(Int32)	Inicializuje novou instanci TimeSpan struktury na zadaný počet hodin.
FromMicroseconds(Double)	Vrátí hodnotu TimeSpan , která představuje zadaný počet mikrosekund.
FromMicroseconds(Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet mikrosekund.
FromMilliseconds(Double)	Vrátí hodnotu TimeSpan , která představuje zadaný počet milisekund.
FromMilliseconds(Int64, Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet milisekund a mikrosekund.
FromMilliseconds(Int64)	Inicializuje novou instanci TimeSpan struktury na 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.
FromMinutes(Int64, Int64, Int64, Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet minut, sekund, milisekund a mikrosekund.
FromMinutes(Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet minut.
FromSeconds(Double)	Vrátí hodnotu TimeSpan , která představuje zadaný počet sekund, kde je specifikace přesná na nejbližší milisekundu.
FromSeconds(Int64, Int64, Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet sekund, milisekundy a mikrosekundy.
FromSeconds(Int64)	Inicializuje novou instanci TimeSpan struktury na zadaný počet sekund.
FromTicks(Int64)	Vrátí hodnotu TimeSpan , která představuje zadaný čas, kde je specifikace v jednotkách záškrtů.
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 rozsahu časového intervalu na jeho TimeSpan ekvivalent pomocí zadaných informací o formátu specifické pro jazykovou verzi.
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.
Parse(String)	Převede řetězcovou reprezentaci časového intervalu na jeho TimeSpan ekvivalent.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Převede rozsah znaků č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é reprezentace se musí přesně shodovat se zadaným formátem.
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ém pro jazykovou verzi a stylů. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaných formátů.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Převede řetězcové vyjádření časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylů. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.
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é reprezentace se musí přesně shodovat se zadaným formátem.
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ém pro jazykovou verzi a stylů. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaných formátů.
ParseExact(String, String[], IFormatProvider)	Převede řetězcové vyjádření časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného pole formátových řetězců a informací o formátu specifické pro jazykovou verzi. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaných formátů.
Subtract(TimeSpan)	Vrátí nový TimeSpan objekt, jehož hodnota je rozdílem 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, 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ém pro jazykovou verzi.
ToString(String)	Převede hodnotu aktuálního TimeSpan objektu na ekvivalentní řetězcové vyjádření pomocí zadaného formátu.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance jako UTF-8 do poskytnutého rozsahu bajtů.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance časového rozsahu na zadaný rozsah znaků.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Převede reprezentaci časového intervalu na ekvivalent TimeSpan pomocí zadaných informací o formátování specifické pro jazykovou verzi a vrátí hodnotu, která určuje, zda byl převod ú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 převod proběhl úspěšně.
TryParse(String, IFormatProvider, TimeSpan)	Převede řetězcové vyjádření č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ězcové vyjádření časového intervalu na jeho TimeSpan ekvivalent a vrátí hodnotu, která označuje, zda 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é reprezentace se musí přesně shodovat se zadaným formátem.
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á určuje, zda byl převod úspěšný. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.
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ém pro jazykovou verzi. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaný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í o formátu specifickém pro jazykovou verzi a stylů. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaný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é reprezentace se musí přesně shodovat se zadaným formátem.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Převede řetězcové vyjádření časového intervalu na jeho TimeSpan ekvivalent pomocí zadaného formátu, informací o formátu specifickém pro jazykovou verzi a stylů. Formát řetězcové reprezentace se musí přesně shodovat se zadaným formátem.
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ém pro jazykovou verzi. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaný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í o formátu specifickém pro jazykovou verzi a stylů. Formát řetězcové reprezentace se musí přesně shodovat s jedním ze zadaných formátů.

Operátory

Name	Description
Addition(TimeSpan, TimeSpan)	Přidá dvě zadané TimeSpan instance.
Division(TimeSpan, Double)	Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem vydělení timeSpan určeného zadaného divisorobjektu .
Division(TimeSpan, TimeSpan)	Vrátí novou Double hodnotu, která je výsledkem dělení t1t2.
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ému zadanému .TimeSpan
Inequality(TimeSpan, TimeSpan)	Určuje, zda se dvě TimeSpan instance nerovnají.
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ému zadanému .TimeSpan
Multiply(Double, TimeSpan)	Vrátí nový TimeSpan objekt, jehož hodnota je výsledkem ná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 zadanou TimeSpan od jiného zadaného parametru TimeSpan.
UnaryNegation(TimeSpan)	TimeSpan Vrátí hodnotu, jejíž hodnota je negovaná hodnota zadané instance.
UnaryPlus(TimeSpan)	Vrátí zadanou instanci TimeSpan.

Viz také

• DateTime
• DateTimeOffset
• Calendar