TimeSpan Yapı

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

TimeSpan.cs

Bir zaman aralığını temsil eder.

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

Devralma

Object

ValueType

TimeSpan

Uygulamalar

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

Örnekler

Aşağıdaki örnek, iki tarih arasındaki farkı temsil eden bir TimeSpan nesnenin örneğini oluşturur. Ardından nesnenin TimeSpan özelliklerini görüntüler.

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

Açıklamalar

TimeSpan Nesne, süre veya geçen süre olarak ölçülen, pozitif veya negatif gün, saat, dakika, saniye ve bir saniyenin kesirlerinden oluşan bir zaman aralığını temsil eder. Yapı TimeSpan , günün saatini temsil etmek için de kullanılabilir, ancak yalnızca saat belirli bir tarihle ilişkili değilse. Aksi takdirde, DateTime veya DateTimeOffset yapısı kullanılmalıdır. (Günün saatini yansıtmak için yapısını kullanma TimeSpan hakkında daha fazla bilgi için bkz. DateTime, DateTimeOffset, TimeSpan ve TimeZoneInfo Arasında Seçim Yapma.)

Note

Değer TimeSpan bir zaman aralığını temsil eder ve belirli sayıda gün, saat, dakika, saniye ve milisaniye olarak ifade edilebilir. Belirli bir başlangıç veya bitiş noktasına başvurmadan genel bir aralığı temsil ettiğinden, her ikisi de değişken sayıda güne sahip olan yıl ve ay cinsinden ifade edilemez. Belirli bir DateTime saat dilimine başvurmadan tarih ve saati temsil eden bir değerden veya belirli bir saat anını temsil eden bir DateTimeOffset değerden farklıdır.

Yapının süreyi ölçmek için kullandığı en büyük zaman TimeSpan birimi bir gündür. Aylar ve yıllar gibi daha büyük zaman birimlerindeki gün sayısı değiştiğinden, zaman aralıkları tutarlılık için gün cinsinden ölçülür.

Bir TimeSpan nesnenin değeri, temsil edilen zaman aralığına eşit olan onay işareti sayısıdır. Bir tik 100 nanosaniyeye veya saniyenin on milyonda birine eşittir. Bir TimeSpan nesnesinin değeri TimeSpan.MinValue ile TimeSpan.MaxValue arasında değişebilir.

TimeSpan değerini örneklendir

Bir değerin örneğini TimeSpan çeşitli yollarla oluşturabilirsiniz:

• Gizli parametresiz oluşturucusunu çağırarak. Bu, aşağıdaki örnekte gösterildiği gibi değeri TimeSpan.Zeroolan bir nesne oluşturur.

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

• Açıkça tanımlanmış oluşturucularından birini çağırarak. Aşağıdaki örnek, belirtilen saat, dakika ve saniye sayısı olarak bir TimeSpan değerini başlatır.

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

• Bir yöntemi çağırarak veya değer döndüren bir TimeSpan işlem gerçekleştirerek. Örneğin, aşağıdaki örnekte gösterildiği gibi iki tarih ve saat değeri arasındaki aralığı temsil eden bir TimeSpan değerin örneğini oluşturabilirsiniz.

  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
  

  Aşağıdaki örnekte gösterildiği gibi, bir nesneyi sıfır saat değerine bu şekilde de başlatabilirsiniz TimeSpan .

  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 değerleri, DateTime, DateTimeOffset ve TimeSpan yapıların aritmetik işleçleri ve yöntemleri tarafından döndürülür.

• Bir TimeSpan değerinin dizge gösterimini ayrıştırarak. Zaman aralıkları içeren dizeleri Parse değerlere dönüştürmek için TryParse ve TimeSpan yöntemlerini kullanabilirsiniz. Aşağıdaki örnek, dize dizisini Parse değerlere dönüştürmek için TimeSpan yöntemini kullanır.

  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'
  

  Ayrıca, veya TimeSpan yöntemini çağırarak ayrıştırılacak ve bir ParseExact değere dönüştürülecek giriş dizesinin TryParseExact tam biçimini tanımlayabilirsiniz.

TimeSpan değerlerinde işlem gerçekleştirme

Addition ve Subtraction işleçlerini veya Add ve Subtract yöntemlerini çağırarak zaman sürelerini ekleyebilir ve çıkarabilirsiniz. ayrıca Compare, CompareTo ve Equals yöntemlerini çağırarak iki süreyi karşılaştırabilirsiniz. Yapı TimeSpan, Duration ve Negate yöntemlerini de içerir ve zaman aralıklarını pozitif ve negatif değerlere dönüştürür.

TimeSpan değerlerinin aralığı MinValue ile MaxValue arasındadır.

TimeSpan değerini biçimlendirme

Bir TimeSpan değer [-]d olarak gösterilebilir.ss:mm:ss. ff, burada isteğe bağlı eksi işareti negatif bir zaman aralığını gösterir, d bileşeni gün, ss 24 saatlik bir saatte ölçülen saat, mm dakika, ss saniye ve ff saniye kesirleridir. Başka bir ifadeyle, bir zaman aralığı, gün saati olmayan pozitif veya negatif gün sayısından, günün saati olan gün sayısından veya yalnızca günün saatinden oluşur.

Yapı, TimeSpan yönteminin aşırı yüklemeleri ToString aracılığıyla kültüre duyarlı biçimlendirmeyi destekler ve bu da bir TimeSpan değeri dize gösterimine dönüştürür. Aşırı yükleme, TimeSpan.ToString(String) zaman aralığının dize gösterimini tanımlayan bir biçim dizesi belirtmenize olanak tanır. TimeSpan.ToString(String, IFormatProvider) aşırı yükleme, bir biçim dizesini ve biçimlendirme kuralları kullanılan kültürü belirterek zaman aralığının dize olarak gösterimini oluşturmanıza olanak tanır. TimeSpan hem standart hem de özel biçim dizelerini destekler. (Daha fazla bilgi için bkz. Standart TimeSpan Biçim Dizeleri ve Özel TimeSpan Biçim Dizeleri.) Ancak, yalnızca standart biçim dizeleri kültüre duyarlıdır.

Oluşturucular

Name	Description
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda gün, saat, dakika, saniye, milisaniye ve mikrosaniye olarak başlatır.
TimeSpan(Int32, Int32, Int32, Int32, Int32)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda gün, saat, dakika, saniye ve milisaniyeye başlatır.
TimeSpan(Int32, Int32, Int32, Int32)	Belirtilen gün, saat, dakika ve saniye sayısına kadar yapının yeni bir örneğini TimeSpan başlatır.
TimeSpan(Int32, Int32, Int32)	Belirtilen saat, dakika ve saniye sayısına kadar yapının yeni bir örneğini TimeSpan başlatır.
TimeSpan(Int64)	Belirtilen sayıda onay işareti için yapının yeni bir örneğini TimeSpan başlatır.

Alanlar

Name	Description
HoursPerDay	1 gün içindeki saat sayısını temsil eder. Bu alan sabittir.
MaxValue	En büyük TimeSpan değeri temsil eder. Bu alan salt okunurdur.
MicrosecondsPerDay	1 gün içindeki mikrosaniye sayısını temsil eder. Bu alan sabittir.
MicrosecondsPerHour	1 saat içindeki mikrosaniye sayısını temsil eder. Bu alan sabittir.
MicrosecondsPerMillisecond	1 milisaniye cinsinden mikrosaniye sayısını temsil eder. Bu alan sabittir.
MicrosecondsPerMinute	1 dakika içinde mikrosaniye sayısını temsil eder. Bu alan sabittir.
MicrosecondsPerSecond	1 saniye içinde mikrosaniye sayısını temsil eder. Bu alan sabittir.
MillisecondsPerDay	1 gün içindeki milisaniye sayısını temsil eder. Bu alan sabittir.
MillisecondsPerHour	1 saat içindeki milisaniye sayısını temsil eder. Bu alan sabittir.
MillisecondsPerMinute	1 dakika içinde milisaniye sayısını temsil eder. Bu alan sabittir.
MillisecondsPerSecond	1 saniye içinde milisaniye sayısını temsil eder. Bu alan sabittir.
MinutesPerDay	1 gün içindeki dakika sayısını temsil eder. Bu alan sabittir.
MinutesPerHour	1 saat içindeki dakika sayısını temsil eder. Bu alan sabittir.
MinValue	En düşük TimeSpan değeri temsil eder. Bu alan salt okunurdur.
NanosecondsPerTick	Değer başına nanosaniye sayısını temsil eder. Bu alan sabittir.
SecondsPerDay	1 gün içindeki saniye sayısını temsil eder. Bu alan sabittir.
SecondsPerHour	1 saat içindeki saniye sayısını temsil eder. Bu alan sabittir.
SecondsPerMinute	1 dakika içindeki saniye sayısını temsil eder. Bu alan sabittir.
TicksPerDay	1 gün içindeki kene sayısını temsil eder. Bu alan sabittir.
TicksPerHour	1 saat içindeki kene sayısını temsil eder. Bu alan sabittir.
TicksPerMicrosecond	1 mikrosaniyedeki kene sayısını temsil eder. Bu alan sabittir.
TicksPerMillisecond	1 milisaniye cinsinden kene sayısını temsil eder. Bu alan sabittir.
TicksPerMinute	1 dakikadaki kene sayısını temsil eder. Bu alan sabittir.
TicksPerSecond	1 saniyedeki kene sayısını temsil eder.
Zero	Sıfır TimeSpan değerini temsil eder. Bu alan salt okunurdur.

Özellikler

Name	Description
Days	Geçerli TimeSpan yapıyla temsil edilen zaman aralığının days bileşenini alır.
Hours	Geçerli TimeSpan yapıyla temsil edilen zaman aralığının saat bileşenini alır.
Microseconds	Geçerli TimeSpan yapıyla temsil edilen zaman aralığının mikrosaniye bileşenini alır.
Milliseconds	Geçerli TimeSpan yapıyla temsil edilen zaman aralığının milisaniye bileşenini alır.
Minutes	Geçerli TimeSpan yapıyla temsil edilen zaman aralığının dakika bileşenini alır.
Nanoseconds	Geçerli TimeSpan yapı tarafından temsil edilen zaman aralığının nanosaniye bileşenini alır.
Seconds	Geçerli TimeSpan yapıyla temsil edilen zaman aralığının saniye bileşenini alır.
Ticks	Geçerli TimeSpan yapının değerini temsil eden onay işareti sayısını alır.
TotalDays	Geçerli TimeSpan yapının tam ve kesirli gün cinsinden ifade edilen değerini alır.
TotalHours	Geçerli TimeSpan yapının tam ve kesirli saatlerle ifade edilen değerini alır.
TotalMicroseconds	Geçerli TimeSpan yapının tam ve kesirli mikrosaniye cinsinden ifade edilen değerini alır.
TotalMilliseconds	Geçerli TimeSpan yapının tam ve kesirli milisaniye cinsinden ifade edilen değerini alır.
TotalMinutes	Geçerli TimeSpan yapının tam ve kesirli dakika cinsinden ifade edilen değerini alır.
TotalNanoseconds	Geçerli TimeSpan yapının tam ve kesirli nanosaniye cinsinden ifade edilen değerini alır.
TotalSeconds	Geçerli TimeSpan yapının tam ve kesirli saniye cinsinden ifade edilen değerini alır.

Yöntemler

Name	Description
Add(TimeSpan)	Değeri belirtilen TimeSpan nesnenin ve bu örneğin toplamı olan yeni TimeSpan bir nesne döndürür.
Compare(TimeSpan, TimeSpan)	İki TimeSpan değeri karşılaştırır ve ilk değerin ikinci değerden daha kısa, buna eşit veya daha uzun olduğunu belirten bir tamsayı döndürür.
CompareTo(Object)	Bu örneği belirtilen nesneyle karşılaştırır ve bu örneğin belirtilen nesneden daha kısa, ona eşit veya daha uzun olduğunu belirten bir tamsayı döndürür.
CompareTo(TimeSpan)	Bu örneği belirtilen TimeSpan bir nesneyle karşılaştırır ve bu örneğin nesneden daha kısa, ona eşit veya nesneden daha TimeSpan uzun olup olmadığını gösteren bir tamsayı döndürür.
Divide(Double)	Değeri, bu örneği belirtilen TimeSpandeğerine bölmenin sonucu olan yeni divisor bir nesne döndürür.
Divide(TimeSpan)	Bu örneği Doubleile bölmenin sonucu olan yeni ts bir değer döndürür.
Duration()	Değeri geçerli TimeSpan nesnenin mutlak değeri olan yeni TimeSpan bir nesne döndürür.
Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
Equals(TimeSpan, TimeSpan)	belirtilen iki örneğinin TimeSpan eşit olup olmadığını gösteren bir değer döndürür.
Equals(TimeSpan)	Bu örneğin belirtilen TimeSpan bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
FromDays(Double)	Belirtimin en yakın milisaniyeye doğru olduğu belirtilen gün sayısını temsil eden bir TimeSpan döndürür.
FromDays(Int32, Int32, Int64, Int64, Int64, Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda gün, saat, dakika, saniye, milisaniye ve mikrosaniye olarak başlatır.
FromDays(Int32)	Belirtilen sayıda gün için yapının yeni bir örneğini TimeSpan başlatır.
FromHours(Double)	Belirtimin en yakın milisaniyeye doğru olduğu belirtilen saat sayısını temsil eden bir TimeSpan döndürür.
FromHours(Int32, Int64, Int64, Int64, Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda saat, dakika, saniye, milisaniye ve mikrosaniye olarak başlatır.
FromHours(Int32)	Belirtilen saat sayısına kadar yapının yeni bir örneğini TimeSpan başlatır.
FromMicroseconds(Double)	TimeSpan Belirtilen sayıda mikrosaniyeyi temsil eden bir döndürür.
FromMicroseconds(Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda mikrosaniyeye başlatır.
FromMilliseconds(Double)	Belirtilen sayıda milisaniyeyi temsil eden bir TimeSpan döndürür.
FromMilliseconds(Int64, Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda milisaniye ve mikrosaniye olarak başlatır.
FromMilliseconds(Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda milisaniyeye başlatır.
FromMinutes(Double)	Belirtimin en yakın milisaniyeye doğru olduğu belirtilen dakika sayısını temsil eden bir TimeSpan döndürür.
FromMinutes(Int64, Int64, Int64, Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda dakika, saniye, milisaniye ve mikrosaniye olarak başlatır.
FromMinutes(Int64)	Belirtilen dakika sayısına kadar yapının yeni bir örneğini TimeSpan başlatır.
FromSeconds(Double)	Belirtimin en yakın milisaniyeye doğru olduğu belirtilen saniye sayısını temsil eden bir TimeSpan döndürür.
FromSeconds(Int64, Int64, Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda saniye, milisaniye ve mikrosaniye olarak başlatır.
FromSeconds(Int64)	Yapının yeni bir örneğini TimeSpan belirtilen sayıda saniyeye başlatır.
FromTicks(Int64)	Belirtimin değer birimi cinsinden olduğu belirtilen süreyi temsil eden bir TimeSpan döndürür.
GetHashCode()	Bu örnek için bir karma kodu döndürür.
Multiply(Double)	Bu örneğin ve belirtilen TimeSpanöğesinin çarpımının sonucu olan yeni factor bir nesne döndürür.
Negate()	Değeri bu örneğin negatif değeri olan yeni TimeSpan bir nesne döndürür.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Belirtilen kültüre özgü biçim bilgilerini kullanarak zaman aralığının span gösterimini eşdeğerine TimeSpan dönüştürür.
Parse(String, IFormatProvider)	Belirtilen kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür.
Parse(String)	Bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının karakter aralığını eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Belirtilen biçimleri, kültüre özgü biçim bilgilerini ve stilleri kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stilleri kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
ParseExact(String, String, IFormatProvider)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Belirtilen biçimleri, kültüre özgü biçim bilgilerini ve stilleri kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
ParseExact(String, String[], IFormatProvider)	Belirtilen biçim dizeleri dizisini ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının dize gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
Subtract(TimeSpan)	Değeri belirtilen TimeSpan nesne ile bu örnek arasındaki fark olan yeni TimeSpan bir nesne döndürür.
ToString()	Geçerli TimeSpan nesnenin değerini eşdeğer dize gösterimine dönüştürür.
ToString(String, IFormatProvider)	Belirtilen biçim ve kültüre özgü biçimlendirme bilgilerini kullanarak geçerli TimeSpan nesnenin değerini eşdeğer dize gösterimine dönüştürür.
ToString(String)	Belirtilen biçimi kullanarak geçerli TimeSpan nesnenin değerini eşdeğer dize gösterimine dönüştürür.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini UTF-8 olarak sağlanan bayt aralığına biçimlendirmeye çalışır.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli zaman aralığı sayı örneğinin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak zaman aralığının span gösterimini eşdeğerine TimeSpan dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.
TryParse(ReadOnlySpan<Char>, TimeSpan)	Zaman aralığının span gösterimini eşdeğerine TimeSpan dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.
TryParse(String, IFormatProvider, TimeSpan)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.
TryParse(String, TimeSpan)	Bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen yayılma alanı gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stilleri kullanarak bir zaman aralığının belirtilen span gösterimini eşdeğerine TimeSpan dönüştürür ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Belirtilen biçimleri ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen yayılma alanı gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Belirli biçimleri, kültüre özgü biçim bilgilerini ve stillerini kullanarak bir zaman aralığının belirtilen yayılma alanı gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Belirtilen biçimi, kültüre özgü biçim bilgilerini ve stillerini kullanarak bir zaman aralığının dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimle tam olarak eşleşmelidir.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Belirtilen biçimleri ve kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının belirtilen dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Belirli biçimleri, kültüre özgü biçim bilgilerini ve stillerini kullanarak bir zaman aralığının belirtilen dize gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi, belirtilen biçimlerden biriyle tam olarak eşleşmelidir.

İşleçler

Name	Description
Addition(TimeSpan, TimeSpan)	Belirtilen TimeSpan iki örneği ekler.
Division(TimeSpan, Double)	Değeri belirtilen TimeSpantimeSpanile bölmenin sonucu olan yeni divisor bir nesne döndürür.
Division(TimeSpan, TimeSpan)	ile bölmenin Doublet1sonucu olan yeni t2 bir değer döndürür.
Equality(TimeSpan, TimeSpan)	İki TimeSpan örneğin eşit olup olmadığını gösterir.
GreaterThan(TimeSpan, TimeSpan)	Belirtilen öğesinin belirtilen TimeSpan başka bir TimeSpandeğerinden büyük olup olmadığını gösterir.
GreaterThanOrEqual(TimeSpan, TimeSpan)	Belirtilen bir öğesinin başka bir belirtilen TimeSpanTimeSpandeğerinden büyük veya buna eşit olup olmadığını gösterir.
Inequality(TimeSpan, TimeSpan)	İki TimeSpan örneğin eşit olup olmadığını gösterir.
LessThan(TimeSpan, TimeSpan)	Belirtilen öğesinin başka bir belirtilenden TimeSpanTimeSpanküçük olup olmadığını gösterir.
LessThanOrEqual(TimeSpan, TimeSpan)	Belirtilen bir öğesinin başka bir belirtilen TimeSpanTimeSpandeğerinden küçük veya buna eşit olup olmadığını gösterir.
Multiply(Double, TimeSpan)	Değeri belirtilen ve TimeSpan belirtilen factor örneğin çarpımının sonucu olan yeni timeSpan bir nesne döndürür.
Multiply(TimeSpan, Double)	Değeri belirtilen örneği ve TimeSpanbelirtilen timeSpan öğesini çarpmanın sonucu olan yeni factor bir nesne döndürür.
Subtraction(TimeSpan, TimeSpan)	Belirtilen bir öğesini belirtilen TimeSpan başka bir TimeSpanöğesinin içinden çıkarır.
UnaryNegation(TimeSpan)	Değeri belirtilen örneğin negatif değeri olan bir TimeSpan döndürür.
UnaryPlus(TimeSpan)	Belirtilen örneğini TimeSpandöndürür.

Ayrıca bkz.

• DateTime
• DateTimeOffset
• Calendar