TimeSpan Yapı

Tanım

Bir zaman aralığını temsil eder.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
public value class TimeSpan : IComparable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
[System.Serializable]
public struct TimeSpan : IComparable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
type TimeSpan = struct
    interface IFormattable
type TimeSpan = struct
    interface ISpanFormattable
    interface IFormattable
type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
[<System.Serializable>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
    interface IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), ISpanFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan)
Public Structure TimeSpan
Implements IComparable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan)
Devralma
TimeSpan
Öznitelikler
Uygulamalar

Ö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, pozitif veya negatif gün sayısı, saat, dakika, saniye ve saniyenin kesirleri olarak ölçülen bir zaman aralığını (süre veya geçen süre) temsil eder. Yapı TimeSpan , günün saatini temsil etmek için de kullanılabilir, ancak yalnızca saat belirli bir tarihle ilgili değilse. Aksi takdirde, DateTime bunun yerine veya DateTimeOffset yapısı kullanılmalıdır. (Yapıyı TimeSpan günün saatini yansıtacak şekilde kullanma hakkında daha fazla bilgi için bkz. DateTime, DateTimeOffset, TimeSpan ve TimeZoneInfo Arasında Seçim Yapma.)

Not

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ün içeren yıl ve ay cinsinden ifade edilemez. Belirli bir DateTime saat dilimine başvurmadan bir tarih ve saati temsil eden bir değerden veya belirli bir zaman 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. Zaman aralıkları tutarlılık için gün cinsinden ölçülür, çünkü aylar ve yıllar gibi daha büyük zaman birimlerindeki günlerin sayısı değişir.

Nesnenin TimeSpan değeri, temsil edilen zaman aralığına eşit olan değer çizgisi sayısıdır. Değer çizgisi 100 nanosaniyeye veya saniyenin on milyonda birine eşittir. Bir TimeSpan nesnenin değeri ile TimeSpan.MinValueTimeSpan.MaxValuearasında değişebilir.

Bir TimeSpan Değerini Örnekleme

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

  • Örtük parametresiz oluşturucusunu çağırarak. Bu, değeri aşağıdaki örnekte gösterildiği gibi olan TimeSpan.Zerobir nesnesi 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 oluşturucularından birini çağırarak. Aşağıdaki örnek belirtilen saat, dakika ve saniye sayısına bir değer başlatır TimeSpan .

    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("{0} - {1} = {2}", arrival, departure, travelTime);      
    
    // The example displays the following output:
    //       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
    
    let departure = DateTime(2010, 6, 12, 18, 32, 0)
    let arrival = DateTime(2010, 6, 13, 22, 47, 0)
    let travelTime = arrival - departure  
    printfn $"{arrival} - {departure} = {travelTime}"
    
    // The example displays the following output:
    //       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
    
    Dim departure As DateTime = #06/12/2010 6:32PM#
    Dim arrival As DateTime = #06/13/2010 10:47PM#
    Dim travelTime As TimeSpan = arrival - departure  
    Console.WriteLine("{0} - {1} = {2}", arrival, departure, travelTime)      
    ' The example displays the following output:
    '       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
    

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

       Random rnd = new Random();
    
       TimeSpan timeSpent = TimeSpan.Zero;
    
       timeSpent += GetTimeBeforeLunch();
       timeSpent += GetTimeAfterLunch();
    
       Console.WriteLine("Total time: {0}", timeSpent);
    
       TimeSpan GetTimeBeforeLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
       
       TimeSpan GetTimeAfterLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
    
       // The example displays output like the following:
       //        Total time: 08:00:00
    
    open System
    
    let rnd = Random()
    
    let getTimeBeforeLunch () =
        TimeSpan(rnd.Next(3, 6), 0, 0)
    
    let getTimeAfterLunch() =
        TimeSpan(rnd.Next(3, 6), 0, 0)
    
    do
        let timeSpent = TimeSpan.Zero
    
        let timeSpent = timeSpent + getTimeBeforeLunch ()
        let timeSpent = timeSpent + getTimeAfterLunch ()
    
        printfn $"Total time: {timeSpent}"
    
    
    // The example displays output like the following:
    //        Total time: 08:00:00
    
    Module Example
       Dim rnd As New Random()
       
       Public Sub Main()
          Dim timeSpent As TimeSpan = TimeSpan.Zero
    
          timeSpent += GetTimeBeforeLunch()
          timeSpent += GetTimeAfterLunch()
    
          Console.WriteLine("Total time: {0}", timeSpent)
       End Sub
       
       Private Function GetTimeBeforeLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
       End Function
       
       Private Function GetTimeAfterLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
       End Function
    End Module
    ' The example displays output like the following:
    '       Total time: 08:00:00
    

    TimeSpandeğerleri, , DateTimeOffsetve yapılarının DateTimearitmetik işleçleri ve TimeSpan yöntemleri tarafından döndürülür.

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

    string[] values = { "12", "31.", "5.8:32:16", "12:12:15.95", ".12"};
    foreach (string value in values)
    {
       try {
          TimeSpan ts = TimeSpan.Parse(value);
          Console.WriteLine("'{0}' --> {1}", value, ts);
       }
       catch (FormatException) {
          Console.WriteLine("Unable to parse '{0}'", value);
       }
       catch (OverflowException) {
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value);
       }   
    }
    
    // The example displays the following output:
    //       '12' --> 12.00:00:00
    //       Unable to parse '31.'
    //       '5.8:32:16' --> 5.08:32:16
    //       '12:12:15.95' --> 12:12:15.9500000
    //       Unable to parse '.12'
    
    let values = [| "12"; "31."; "5.8:32:16"; "12:12:15.95"; ".12" |]
    for value in values do
        try
            let ts = TimeSpan.Parse value
            printfn $"'{value}' --> {ts}"
        with 
        | :? FormatException ->
            printfn $"Unable to parse '{value}'"
        | :? OverflowException ->
            printfn $"'{value}' is outside the range of a TimeSpan."
    
    // The example displays the following output:
    //       '12' --> 12.00:00:00
    //       Unable to parse '31.'
    //       '5.8:32:16' --> 5.08:32:16
    //       '12:12:15.95' --> 12:12:15.9500000
    //       Unable to parse '.12'
    
    Dim values() As String = { "12", "31.", "5.8:32:16", "12:12:15.95", ".12"}
    For Each value As String In values
       Try
          Dim ts As TimeSpan = TimeSpan.Parse(value)
          Console.WriteLine("'{0}' --> {1}", value, ts)
       Catch e As FormatException
          Console.WriteLine("Unable to parse '{0}'", value)
       Catch e As OverflowException
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value)
       End Try   
    Next
    ' The example displays the following output:
    '       '12' --> 12.00:00:00
    '       Unable to parse '31.'
    '       '5.8:32:16' --> 5.08:32:16
    '       '12:12:15.95' --> 12:12:15.9500000
    '       Unable to parse '.12'
    

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

TimeSpan Değerleri Üzerinde İşlem Gerçekleştirme

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

Değer aralığı TimeSpan olarak ayarlanır MinValueMaxValue.

TimeSpan Değerini Biçimlendirme

Bir TimeSpan değer [-]d olarak gösterilebilir. ss:dd: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 saat ölçülen saat, mm dakika, ss saniye ve ff saniye kesirleridir. Diğer 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.

.NET Framework 4'ünden başlayarak yapı, yönteminin TimeSpan 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. Varsayılan TimeSpan.ToString() yöntem, .NET Framework önceki sürümlerinde dönüş değeriyle aynı sabit bir biçim kullanarak bir zaman aralığı döndü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. Aşırı yükleme, TimeSpan.ToString(String, IFormatProvider) bir biçim dizesi ve biçimlendirme kuralları zaman aralığının dize gösterimini oluşturmak için kullanılan kültürü belirtmenize 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.

Eski TimeSpan Biçimlendirmesini Geri Yükleme

Bazı durumlarda, .NET Framework 3.5 ve önceki sürümlerdeki değerleri başarıyla biçimlendiren TimeSpan kod .NET Framework 4'te başarısız olur. Bu, bir değeri bir <biçim dizesiyle biçimlendirmek için TimeSpan_LegacyFormatMode> öğesi yöntemini çağıran kodda en yaygın olanıdır.TimeSpan Aşağıdaki örnek, .NET Framework 3.5 ve önceki sürümlerde bir TimeSpan değeri başarıyla biçimlendirse de, .NET Framework 4 ve sonraki sürümlerde özel durum oluşturur. .NET Framework 3.5 ve önceki sürümlerde yoksayılan desteklenmeyen bir biçim tanımlayıcısı kullanarak bir TimeSpan değeri biçimlendirmeye çalıştığına dikkat edin.

ShowFormattingCode();
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format    

Console.WriteLine("---");

ShowParsingCode();
// Output:
//       000000006 --> 6.00:00:00

void ShowFormattingCode()
{
   TimeSpan interval = new TimeSpan(12, 30, 45);
   string output;
   try {
      output = String.Format("{0:r}", interval);
   }
   catch (FormatException) {
      output = "Invalid Format";
   }
   Console.WriteLine(output);
}

void ShowParsingCode()
{
   string value = "000000006";
   try {
      TimeSpan interval = TimeSpan.Parse(value);
      Console.WriteLine("{0} --> {1}", value, interval);
   }
   catch (FormatException) {
      Console.WriteLine("{0}: Bad Format", value);
   }   
   catch (OverflowException) {
      Console.WriteLine("{0}: Overflow", value);
   }
}
let showFormattingCode () =
    let interval = TimeSpan(12, 30, 45)
    try
        $"{interval:r}"
    with :? FormatException ->
        "Invalid Format"
    |> printfn "%s"

let showParsingCode () =
    let value = "000000006"
    try
        let interval = TimeSpan.Parse value
        printfn $"{value} --> {interval}"
    with
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"

showFormattingCode ()
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format    

printfn "---"

showParsingCode ()
// Output:
//       000000006 --> 6.00:00:00
Dim interval As New TimeSpan(12, 30, 45)
Dim output As String
Try
   output = String.Format("{0:r}", interval)
Catch e As FormatException
   output = "Invalid Format"
End Try
Console.WriteLine(output)
' Output from .NET Framework 3.5 and earlier versions:
'       12:30:45
' Output from .NET Framework 4:
'       Invalid Format

Kodu değiştiremiyorsanız, değerlerin eski biçimlendirmesini TimeSpan aşağıdaki yollardan biriyle geri yükleyebilirsiniz:

  • TimeSpan_LegacyFormatMode> öğesini içeren< bir yapılandırma dosyası oluşturarak. Bu öğenin enabled özniteliğini, uygulama başına eski TimeSpan biçimlendirmeyi geri yükecek true şekilde ayarlamak.

  • Uygulama etki alanı oluştururken "NetFx40_TimeSpanLegacyFormatMode" uyumluluk anahtarını ayarlayarak. Bu, uygulama etki alanı temelinde eski TimeSpan biçimlendirmeyi etkinleştirir. Aşağıdaki örnek, eski TimeSpan biçimlendirme kullanan bir uygulama etki alanı oluşturur.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          AppDomainSetup appSetup = new AppDomainSetup();
          appSetup.SetCompatibilitySwitches( new string[] { "NetFx40_TimeSpanLegacyFormatMode" } );
          AppDomain legacyDomain = AppDomain.CreateDomain("legacyDomain", 
                                                          null, appSetup);
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe");
       }
    }
    
    open System
    
    let appSetup = AppDomainSetup()
    appSetup.SetCompatibilitySwitches [| "NetFx40_TimeSpanLegacyFormatMode" |]
    let legacyDomain = AppDomain.CreateDomain("legacyDomain", null, appSetup)
    legacyDomain.ExecuteAssembly "ShowTimeSpan.exe" |> ignore
    
    Module Example
       Public Sub Main()
          Dim appSetup As New AppDomainSetup()
          appSetup.SetCompatibilitySwitches( { "NetFx40_TimeSpanLegacyFormatMode" } )
          Dim legacyDomain As AppDomain = AppDomain.CreateDomain("legacyDomain", 
                                                                 Nothing, appSetup)
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe")
       End Sub
    End Module
    

    Aşağıdaki kod yeni uygulama etki alanında yürütürse eski TimeSpan biçimlendirme davranışına geri döner.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          TimeSpan interval = DateTime.Now - DateTime.Now.Date;
          string msg = String.Format("Elapsed Time Today: {0:d} hours.",
                                     interval);
          Console.WriteLine(msg);
       }
    }
    // The example displays the following output:
    //       Elapsed Time Today: 01:40:52.2524662 hours.
    
    open System
    
    let interval = DateTime.Now - DateTime.Now.Date
    printfn $"Elapsed Time Today: {interval:d} hours."
    // The example displays the following output:
    //       Elapsed Time Today: 01:40:52.2524662 hours.
    
    Module Example
       Public Sub Main()
          Dim interval As TimeSpan = Date.Now - Date.Now.Date
          Dim msg As String = String.Format("Elapsed Time Today: {0:d} hours.",
                                             interval)
          Console.WriteLine(msg)
       End Sub
    End Module
    ' The example displays output like the following:
    '       Elapsed Time Today: 01:40:52.2524662 hours.
    

Oluşturucular

TimeSpan(Int32, Int32, Int32)

Yapının yeni bir örneğini TimeSpan belirtilen saat, dakika ve saniye sayısına başlatır.

TimeSpan(Int32, Int32, Int32, Int32)

Yapının yeni bir örneğini TimeSpan belirtilen gün, saat, dakika ve saniye sayısına 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 milisaniye olarak başlatır.

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(Int64)

Belirtilen sayıda değer çizgisi için yapının yeni bir örneğini TimeSpan başlatır.

Alanlar

MaxValue

En büyük TimeSpan değeri temsil eder. Bu alan salt okunur durumdadır.

MinValue

En düşük TimeSpan değeri temsil eder. Bu alan salt okunur durumdadır.

NanosecondsPerTick

Değer çizgisi başına nanosaniye 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 okunur durumdadır.

Özellikler

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ı tarafından temsil edilen zaman aralığının mikrosaniye bileşenini alır.

Milliseconds

Geçerli TimeSpan yapı tarafından 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 kene 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

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, ona eşit veya daha uzun olduğunu belirten bir tamsayı döndürür.

CompareTo(Object)

Bu örneği belirtilen bir 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ı belirten bir tamsayı döndürür.

Divide(Double)

Bu örneğin ve belirtilen divisorbölümünün sonucu olan yeni TimeSpan bir nesne döndürür.

Divide(TimeSpan)

Bu örneğin ve belirtilen tsbölümünün sonucu olan yeni Double 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ğeri döndürür.

Equals(TimeSpan)

Bu örneğin belirtilen TimeSpan bir nesneye eşit olup olmadığını belirten 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.

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.

FromHours(Double)

Belirtimin en yakın milisaniyeye doğru olduğu belirtilen saat sayısını temsil eden bir TimeSpan döndürür.

FromMicroseconds(Double)

Belirtilen sayıda mikrosaniyeyi temsil eden bir TimeSpan döndürür.

FromMilliseconds(Double)

Belirtilen milisaniye sayısını temsil eden bir TimeSpan döndürü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.

FromSeconds(Double)

Belirtimin en yakın milisaniyeye doğru olduğu belirtilen saniye sayısını temsil eden bir TimeSpan döndürür.

FromTicks(Int64)

Belirtimin değer birimi cinsinden olduğu belirtilen zamanı 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 factoröğesinin çarpımının sonucu olan yeni TimeSpan bir nesne döndürür.

Negate()

Değeri bu örneğin olumsuz değeri olan yeni TimeSpan bir nesne döndürür.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Belirtilen kültüre özgü biçim bilgilerini kullanarak bir zaman aralığının span 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.

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.

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

Belirtilen biçimi 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çimlerinden biriyle tam olarak eşleşmelidir.

ParseExact(String, String, IFormatProvider)

Belirtilen biçimi 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ç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 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çimlerinden biriyle 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çimlerinden 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)

Belirtilen biçimi kullanarak geçerli TimeSpan nesnenin değerini eşdeğer dize gösterimine dönüştürür.

ToString(String, IFormatProvider)

Belirtilen biçimi 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.

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ı belirten 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 span 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 span gösterimini TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi belirtilen biçimlerinden biriyle tam olarak eşleşmelidir.

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

Belirtilen biçimler, kültüre özgü biçim bilgileri ve stilleri kullanarak bir zaman aralığının belirtilen span gösterimini eşdeğerine TimeSpan dönüştürür. Dize gösteriminin biçimi belirtilen biçimlerinden biriyle tam olarak eşleşmelidir.

TryParseExact(String, String, IFormatProvider, TimeSpan)

Belirtilen biçimi 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ç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 TimeSpan eşdeğerine dönüştürür. Dize gösteriminin biçimi belirtilen biçimlerinden biriyle tam olarak eşleşmelidir.

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

Belirtilen 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çimlerinden biriyle tam olarak eşleşmelidir.

İşleçler

Addition(TimeSpan, TimeSpan)

Belirtilen TimeSpan iki örneği ekler.

Division(TimeSpan, Double)

Değerinin, örneğin ve belirtilen divisorbölümünün timeSpan sonucu olan yeni TimeSpan bir nesnesi döndürür.

Division(TimeSpan, TimeSpan)

Örneğin ve belirtilen t2bölümünün t1 sonucu olan yeni Double 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 TimeSpan bir öğesinin belirtilen 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 bir öğesinin TimeSpan belirtilen başka bir TimeSpandeğerinden küçü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 factorbelirtilen timeSpan öğesini çarpmanın sonucu olan yeni TimeSpan 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.

Belirtik Arabirim Kullanımları

IComparable.CompareTo(Object)

Bu örneği belirtilen bir 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.

Şunlara uygulanır

Ayrıca bkz.