TimeSpan Struktúra

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

TimeSpan.cs

Időintervallumot jelöl.

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

Öröklődés

Object

ValueType

TimeSpan

Megvalósítás

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

Példák

Az alábbi példa egy TimeSpan olyan objektumot hoz létre, amely a két dátum közötti különbséget jelöli. Ezután megjeleníti az TimeSpan objektum tulajdonságait.

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

Megjegyzések

A TimeSpan objektum olyan időintervallumot (időtartamot vagy eltelt időt) jelöl, amelyet napok, órák, percek, másodpercek és másodperc tört részei pozitív vagy negatív számaként mérnek. A TimeSpan szerkezet a nap időpontját is ábrázolhatja, de csak akkor, ha az idő nem kapcsolódik egy adott dátumhoz. Ellenkező esetben a DateTime vagy DateTimeOffset struktúrát kell használni. (A TimeSpan struktúrának a napidőt tükröző használatával kapcsolatos további információkért lásd: Választás a DateTime, a DateTimeOffset, a TimeSpan és a TimeZoneInfoközött.)

Megjegyzés:

A TimeSpan értékek egy időintervallumot jelölnek, és adott számú nap, óra, perc, másodperc és ezredmásodpercként fejezhetők ki. Mivel egy adott kezdő vagy végpontra való hivatkozás nélküli általános intervallumot jelöl, nem fejezhető ki évek és hónapok szerint, amelyek mindegyike változó számú nappal rendelkezik. Különbözik egy DateTime értéktől, amely egy dátumot és időt jelöl egy adott időzónára való hivatkozás nélkül, vagy egy DateTimeOffset értéket, amely egy adott időpontot jelöl.

A TimeSpan szerkezet által az időtartam mérésére használt legnagyobb időegység egy nap. Az időintervallumok a konzisztencia napjaiban vannak megadva, mivel a nagyobb időegységekben (például hónapokban és években) lévő napok száma változó.

Egy TimeSpan objektum értéke a megadott időintervallummal egyenlő kullancsok száma. Egy tick 100 nanoszekundumnak vagy egy tízmilliomod másodpercnek felel meg. Egy TimeSpan objektum értéke TimeSpan.MinValue és TimeSpan.MaxValueközött mozoghat.

TimeSpan-érték példányosítása

Több módon is létrehozhat TimeSpan értéket:

• Implicit paraméter nélküli konstruktor meghívásával. Ez létrehoz egy objektumot, amelynek értéke TimeSpan.Zero, ahogy az alábbi példa is mutatja.

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

• Az egyik explicit konstruktor meghívásával. Az alábbi példa egy TimeSpan értéket inicializál egy megadott számú órára, percre és másodpercre.

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

• Metódus meghívásával vagy egy olyan művelet végrehajtásával, amely TimeSpan értéket ad vissza. Létrehozhat például egy TimeSpan értéket, amely a két dátum- és időérték közötti intervallumot jelöli, ahogyan az az alábbi példában látható.

  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
  

  Egy TimeSpan objektumot nulla időértékre is inicializálhat így, ahogy az alábbi példa is mutatja.

  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
  

  TimeSpan értékeket a DateTime, DateTimeOffsetés TimeSpan struktúrák számtani operátorai és metódusai adják vissza.

• Egy TimeSpan érték sztringképének elemzésével. Az Parse és TryParse metódusokkal időintervallumokat tartalmazó sztringeket konvertálhat TimeSpan értékekké. Az alábbi példa a Parse metódust használja egy sztringtömb TimeSpan értékké alakításához.

  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'
  

  Emellett a TimeSpan vagy ParseExact metódus meghívásával meghatározhatja az elemezni és TryParseExact értékké konvertálni kívánt bemeneti sztring pontos formátumát.

Műveletek végrehajtása a TimeSpan-értékeken

Az időtartamokat a Addition és Subtraction operátorok használatával, illetve a Add és Subtract metódus meghívásával is hozzáadhatja és kivonhatja. A két időtartamot a Compare, CompareToés Equals metódus meghívásával is összehasonlíthatja. A TimeSpan szerkezet tartalmazza az Duration és Negate metódusokat is, amelyek az időintervallumokat pozitív és negatív értékekké alakítják át,

A TimeSpan értékek tartománya MinValueMaxValue.

TimeSpan-érték formázása

A TimeSpan érték [-]d.óó:mm:ss.ff, ahol az opcionális mínuszjel negatív időintervallumot jelez, a d összetevő napok, óó 24 órás óra, mm perc, ss másodperc, ff másodperc törtrésze. Ez azt jelenti, hogy az időintervallumok pozitív vagy negatív napok számából állnak időpont nélkül, vagy napok számából napszakkal, vagy csak egy napszakból.

A TimeSpan struktúra a metódus túlterhelésével ToString támogatja a kultúraérzékeny formázást, amely egy értéket sztring-ábrázolássá TimeSpan alakít át. A TimeSpan.ToString(String) túlterhelés művelet lehetővé teszi egy olyan formátum karakterlánc megadását, amely meghatározza az időintervallum karakterlánc ábrázolását. A TimeSpan.ToString(String, IFormatProvider) túlterhelés lehetővé teszi egy formátumsztring és annak a kultúrának a megadását, amelynek formázási konvenciói az időintervallum sztring-ábrázolásának létrehozásához használatosak. TimeSpan szabványos és egyéni formátum sztringeket is támogat. (További információ: Standard TimeSpan Format Strings és Custom TimeSpan Format Strings.) Azonban csak a szabványos formátumú sztringek kulturális szempontból érzékenyek.

Konstruktorok

Name	Description
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)	Inicializálja a TimeSpan struktúra új példányát megadott számú napra, órára, percre, másodpercre, ezredmásodpercre és mikroszekundumra.
TimeSpan(Int32, Int32, Int32, Int32, Int32)	Inicializálja a TimeSpan struktúra új példányát megadott számú napra, órára, percre, másodpercre és ezredmásodpercre.
TimeSpan(Int32, Int32, Int32, Int32)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú napra, órára, percre és másodpercre.
TimeSpan(Int32, Int32, Int32)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú órára, percre és másodpercre.
TimeSpan(Int64)	Inicializálja a TimeSpan struktúra új példányát a megadott számú kullancsra.

Mezők

Name	Description
HoursPerDay	Az órák számát jelöli 1 nap alatt. Ez a mező állandó.
MaxValue	A maximális TimeSpan értéket jelöli. Ez a mező csak olvasható.
MicrosecondsPerDay	A mikroszekundumok számát jelöli 1 nap alatt. Ez a mező állandó.
MicrosecondsPerHour	A mikroszekundumok számát jelöli 1 óra alatt. Ez a mező állandó.
MicrosecondsPerMillisecond	A mikroszekundumok számát jelöli 1 ezredmásodpercben. Ez a mező állandó.
MicrosecondsPerMinute	A mikroszekundumok számát jelöli 1 perc alatt. Ez a mező állandó.
MicrosecondsPerSecond	A mikroszekundumok számát jelöli 1 másodperc alatt. Ez a mező állandó.
MillisecondsPerDay	Az ezredmásodpercek számát jelöli 1 nap alatt. Ez a mező állandó.
MillisecondsPerHour	Az ezredmásodpercek számát jelöli 1 óra alatt. Ez a mező állandó.
MillisecondsPerMinute	Az ezredmásodpercek számát jelöli 1 perc alatt. Ez a mező állandó.
MillisecondsPerSecond	Az ezredmásodpercek számát jelöli 1 másodperc alatt. Ez a mező állandó.
MinutesPerDay	A percek számát jelöli 1 nap alatt. Ez a mező állandó.
MinutesPerHour	A percek számát jelöli 1 óra alatt. Ez a mező állandó.
MinValue	A minimális TimeSpan értéket jelöli. Ez a mező csak olvasható.
NanosecondsPerTick	A négyzetenkénti nanoszekundumok számát jelöli. Ez a mező állandó.
SecondsPerDay	A másodpercek számát jelöli 1 nap alatt. Ez a mező állandó.
SecondsPerHour	A másodpercek számát jelöli 1 óra alatt. Ez a mező állandó.
SecondsPerMinute	A másodpercek számát jelöli 1 perc alatt. Ez a mező állandó.
TicksPerDay	A kullancsok számát jelöli 1 nap alatt. Ez a mező állandó.
TicksPerHour	A kullancsok számát jelöli 1 óra alatt. Ez a mező állandó.
TicksPerMicrosecond	A kullancsok számát jelöli 1 mikroszekundumban. Ez a mező állandó.
TicksPerMillisecond	A kullancsok számát jelöli 1 ezredmásodpercben. Ez a mező állandó.
TicksPerMinute	A kullancsok számát jelöli 1 perc alatt. Ez a mező állandó.
TicksPerSecond	A kullancsok számát jelöli 1 másodperc alatt.
Zero	A nulla TimeSpan értéket jelöli. Ez a mező csak olvasható.

Tulajdonságok

Name	Description
Days	Lekéri az aktuális TimeSpan struktúra által képviselt időintervallum napok összetevőjét.
Hours	Lekéri az aktuális TimeSpan struktúra által képviselt időintervallum óraösszetevőjét.
Microseconds	Lekéri az aktuális TimeSpan struktúra által képviselt időintervallum mikroszekundum-összetevőjét.
Milliseconds	Lekéri az aktuális TimeSpan struktúra által képviselt időintervallum ezredmásodperc összetevőjét.
Minutes	Lekéri az aktuális TimeSpan struktúra által képviselt időintervallum percösszetevőjét.
Nanoseconds	Lekéri az aktuális TimeSpan struktúra által képviselt időintervallum nanoszekundum-összetevőjét.
Seconds	Lekéri az aktuális TimeSpan struktúra által képviselt időintervallum másodperces összetevőjét.
Ticks	Lekéri az aktuális TimeSpan struktúra értékét képviselő kullancsok számát.
TotalDays	Az aktuális TimeSpan struktúra egész és tört napban kifejezett értékét adja meg.
TotalHours	Lekéri az aktuális TimeSpan struktúra egész és tört órákban kifejezett értékét.
TotalMicroseconds	Az aktuális TimeSpan struktúra egész és tört mikroszekundumban kifejezett értékét adja meg.
TotalMilliseconds	Az aktuális TimeSpan struktúra egész és tört ezredmásodpercben kifejezett értékét adja meg.
TotalMinutes	Lekéri az aktuális TimeSpan struktúra egész és tört percben kifejezett értékét.
TotalNanoseconds	A jelenlegi TimeSpan struktúra egész és tört nanoszekundumban kifejezett értékét adja meg.
TotalSeconds	Lekéri az aktuális TimeSpan struktúra egész és tört másodpercben kifejezett értékét.

Metódusok

Name	Description
Add(TimeSpan)	Egy új TimeSpan objektumot ad vissza, amelynek értéke a megadott TimeSpan objektum és a példány összege.
Compare(TimeSpan, TimeSpan)	Két TimeSpan értéket hasonlít össze, és egy egész számot ad vissza, amely azt jelzi, hogy az első érték rövidebb, egyenlő vagy hosszabb a második értéknél.
CompareTo(Object)	Összehasonlítja ezt a példányt egy adott objektummal, és egy egész számot ad vissza, amely azt jelzi, hogy ez a példány rövidebb, egyenlő vagy hosszabb-e, mint a megadott objektum.
CompareTo(TimeSpan)	Összehasonlítja ezt a példányt egy adott TimeSpan objektummal, és egy egész számot ad vissza, amely azt jelzi, hogy ez a példány rövidebb, egyenlő vagy hosszabb-e, mint az TimeSpan objektum.
Divide(Double)	Egy új TimeSpan objektumot ad vissza, amelynek az az eredménye, hogy a példányt elosztja a megadott divisorértékkel.
Divide(TimeSpan)	Egy új Double értéket ad vissza, amelynek az az eredménye, hogy a példányt elosztja a következővel ts: .
Duration()	Egy új TimeSpan objektumot ad vissza, amelynek értéke az aktuális TimeSpan objektum abszolút értéke.
Equals(Object)	Egy értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott objektummal.
Equals(TimeSpan, TimeSpan)	Egy értéket ad vissza, amely jelzi, hogy két megadott példány TimeSpan egyenlő-e.
Equals(TimeSpan)	Egy értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott TimeSpan objektummal.
FromDays(Double)	TimeSpan Megadott számú napot tartalmazó értéket ad vissza, ahol a specifikáció a legközelebbi ezredmásodpercig pontos.
FromDays(Int32, Int32, Int64, Int64, Int64, Int64)	Inicializálja a TimeSpan struktúra új példányát megadott számú napra, órára, percre, másodpercre, ezredmásodpercre és mikroszekundumra.
FromDays(Int32)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú napra.
FromHours(Double)	TimeSpan Megadott számú órát tartalmazó értéket ad vissza, ahol a specifikáció a legközelebbi ezredmásodpercig pontos.
FromHours(Int32, Int64, Int64, Int64, Int64)	Inicializálja a TimeSpan struktúra új példányát megadott számú órára, percre, másodpercre, ezredmásodpercre és mikroszekundumra.
FromHours(Int32)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú órára.
FromMicroseconds(Double)	TimeSpan Megadott számú mikroszekundumot képviselő értéket ad vissza.
FromMicroseconds(Int64)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú mikroszekundumra.
FromMilliseconds(Double)	TimeSpan Megadott számú ezredmásodpercet képviselő értéket ad vissza.
FromMilliseconds(Int64, Int64)	Inicializálja a TimeSpan struktúra új példányát meghatározott számú ezredmásodpercre és mikroszekundumra.
FromMilliseconds(Int64)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú ezredmásodpercre.
FromMinutes(Double)	TimeSpan Megadott számú perc értéket ad vissza, ahol a specifikáció a legközelebbi ezredmásodpercig pontos.
FromMinutes(Int64, Int64, Int64, Int64)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú percre, másodpercre, ezredmásodpercre és mikroszekundumra.
FromMinutes(Int64)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú percre.
FromSeconds(Double)	Megadott számú másodpercet tartalmazó értéket ad TimeSpan vissza, ahol a specifikáció a legközelebbi ezredmásodpercig pontos.
FromSeconds(Int64, Int64, Int64)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú másodpercre, ezredmásodpercre és mikroszekundumra.
FromSeconds(Int64)	Inicializálja a TimeSpan struktúra új példányát egy megadott számú másodpercre.
FromTicks(Int64)	Egy megadott időpontot TimeSpan képviselő értéket ad vissza, ahol a specifikáció a kullancsok egységében van.
GetHashCode()	Egy kivonatkódot ad vissza ehhez a példányhoz.
Multiply(Double)	Egy új TimeSpan objektumot ad vissza, amely a példány és a megadott factorszorzás eredménye.
Negate()	Egy új TimeSpan objektumot ad vissza, amelynek értéke ennek a példánynak a negated értéke.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Egy időintervallum span-ábrázolását a megadott kultúraspecifikus formátuminformációk használatával konvertálja TimeSpan annak megfelelővé.
Parse(String, IFormatProvider)	Az időintervallum sztring-ábrázolását a megadott kultúraspecifikus formátumadatok használatával konvertálja TimeSpan annak megfelelővé.
Parse(String)	Átalakítja egy időintervallum sztringképét annak megfelelőjeként TimeSpan .
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Az időintervallum karaktertartományát a megadott formátum- és kultúraspecifikus formátuminformációk használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Az időintervallum sztring-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílusok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Az időintervallum sztring-ábrázolását a megadott formátum, kultúraspecifikus formátumadatok és stílusok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
ParseExact(String, String, IFormatProvider)	Az időintervallum sztring-ábrázolását a megadott formátum- és kultúraspecifikus formátumadatok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Az időintervallum sztring-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílusok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.
ParseExact(String, String[], IFormatProvider)	Az időintervallum TimeSpan sztring-ábrázolását a megadott formátumsztringek és kultúraspecifikus formátuminformációk segítségével konvertálja annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.
Subtract(TimeSpan)	Egy új TimeSpan objektumot ad vissza, amelynek értéke a megadott TimeSpan objektum és a példány közötti különbség.
ToString()	Az aktuális TimeSpan objektum értékét a megfelelő sztring-ábrázolásúvá alakítja.
ToString(String, IFormatProvider)	Az aktuális TimeSpan objektum értékét a megadott formátum- és kultúraspecifikus formázási információk használatával konvertálja a megfelelő sztringre.
ToString(String)	Az aktuális TimeSpan objektum értékét a megadott formátum használatával konvertálja az azzal egyenértékű sztringre.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Az aktuális példány értékét UTF-8 formátumban próbálja formázni a megadott bájttartományba.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Megpróbálja formázni az aktuális időtartomány-példány értékét a megadott karaktertartományba.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Egy időintervallum TimeSpan span-ábrázolását a megadott kultúraspecifikus formázási információk használatával konvertálja annak megfelelővé, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryParse(ReadOnlySpan<Char>, TimeSpan)	Átalakítja egy időintervallum span ábrázolását annak TimeSpan megfelelőjeként, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryParse(String, IFormatProvider, TimeSpan)	Az időintervallum TimeSpan sztring-ábrázolását a megadott kultúraspecifikus formázási információk használatával konvertálja annak megfelelővé, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryParse(String, TimeSpan)	Átalakítja egy időintervallum sztringképét annak TimeSpan megfelelőjeként, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Az időintervallum megadott span-ábrázolását a megadott formátum- és kultúraspecifikus formátumadatok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Az időintervallum TimeSpan megadott span-ábrázolását a megadott formátum, kultúraspecifikus formátumadatok és stílusok használatával konvertálja annak megfelelővé, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Az időintervallum megadott span-ábrázolását a megadott formátumok és kultúraspecifikus formátumadatok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Az időintervallum megadott span-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílusok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Az időintervallum sztring-ábrázolását a megadott formátum- és kultúraspecifikus formátumadatok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Az időintervallum sztringképét a megadott formátum, kultúraspecifikus formátumadatok és stílusok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátummal.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Az időintervallum megadott sztring-ábrázolását a megadott formátumok és kultúraspecifikus formátumadatok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Az időintervallum megadott sztring-ábrázolását a megadott formátumok, kultúraspecifikus formátumadatok és stílusok használatával konvertálja TimeSpan annak megfelelővé. A sztring-ábrázolás formátumának pontosan meg kell egyeznie a megadott formátumok egyikével.

Operátorok

Name	Description
Addition(TimeSpan, TimeSpan)	Két megadott példányt ad TimeSpan hozzá.
Division(TimeSpan, Double)	Egy új TimeSpan objektumot ad vissza, amelynek az értéke a megadott timeSpandivisorérték szerinti osztás eredménye.
Division(TimeSpan, TimeSpan)	Egy új Double értéket ad vissza, amely a osztás t1 eredménye t2.
Equality(TimeSpan, TimeSpan)	Azt jelzi, hogy két TimeSpan példány egyenlő-e.
GreaterThan(TimeSpan, TimeSpan)	Azt jelzi, hogy egy megadott TimeSpan nagyobb-e egy másik megadottnál TimeSpan.
GreaterThanOrEqual(TimeSpan, TimeSpan)	Azt jelzi, hogy a megadott TimeSpan érték nagyobb-e, mint egy másik megadott TimeSpan.
Inequality(TimeSpan, TimeSpan)	Azt jelzi, hogy két TimeSpan példány nem egyenlő-e.
LessThan(TimeSpan, TimeSpan)	Azt jelzi, hogy a megadott TimeSpan érték kisebb-e egy másik megadottnál TimeSpan.
LessThanOrEqual(TimeSpan, TimeSpan)	Azt jelzi, hogy a megadott TimeSpan érték kisebb-e, mint egy másik megadott TimeSpan.
Multiply(Double, TimeSpan)	Egy új TimeSpan objektumot ad vissza, amelynek értéke a megadott factor és a megadott timeSpan példány szorzásának eredménye.
Multiply(TimeSpan, Double)	Egy új TimeSpan objektumot ad vissza, amelynek értéke a megadott példány és a megadott timeSpanfactorpéldány szorzásának eredménye.
Subtraction(TimeSpan, TimeSpan)	A megadott TimeSpan értéket kivonja egy másik megadottból TimeSpan.
UnaryNegation(TimeSpan)	Egy olyan értéket ad TimeSpan vissza, amelynek értéke a megadott példány negated értéke.
UnaryPlus(TimeSpan)	A megadott példányt TimeSpanadja vissza.

Lásd még

• DateTime
• DateTimeOffset
• Calendar