TimeSpan 結構

定義

表示時間間隔。

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public value class TimeSpan : IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>, IAdditiveIdentity<TimeSpan, TimeSpan>, IComparable<TimeSpan>, IComparisonOperators<TimeSpan, TimeSpan>, IDivisionOperators<TimeSpan, double, TimeSpan>, IDivisionOperators<TimeSpan, TimeSpan, double>, IEqualityOperators<TimeSpan, TimeSpan>, IEquatable<TimeSpan>, IMinMaxValue<TimeSpan>, IMultiplicativeIdentity<TimeSpan, double>, IMultiplyOperators<TimeSpan, double, TimeSpan>, IParseable<TimeSpan>, ISpanFormattable, ISpanParseable<TimeSpan>, ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>, IUnaryNegationOperators<TimeSpan, TimeSpan>, IUnaryPlusOperators<TimeSpan, TimeSpan>
public value class TimeSpan : IComparable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public readonly struct TimeSpan : IAdditionOperators<TimeSpan,TimeSpan,TimeSpan>, IAdditiveIdentity<TimeSpan,TimeSpan>, IComparable<TimeSpan>, IComparisonOperators<TimeSpan,TimeSpan>, IDivisionOperators<TimeSpan,double,TimeSpan>, IDivisionOperators<TimeSpan,TimeSpan,double>, IEqualityOperators<TimeSpan,TimeSpan>, IEquatable<TimeSpan>, IMinMaxValue<TimeSpan>, IMultiplicativeIdentity<TimeSpan,double>, IMultiplyOperators<TimeSpan,double,TimeSpan>, IParseable<TimeSpan>, ISpanFormattable, ISpanParseable<TimeSpan>, ISubtractionOperators<TimeSpan,TimeSpan,TimeSpan>, IUnaryNegationOperators<TimeSpan,TimeSpan>, IUnaryPlusOperators<TimeSpan,TimeSpan>
[System.Serializable]
public struct TimeSpan : IComparable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
type TimeSpan = struct
    interface IFormattable
type TimeSpan = struct
    interface ISpanFormattable
    interface IFormattable
type TimeSpan = struct
    interface ISpanFormattable
    interface IFormattable
    interface IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>
    interface IAdditiveIdentity<TimeSpan, TimeSpan>
    interface IComparisonOperators<TimeSpan, TimeSpan>
    interface IEqualityOperators<TimeSpan, TimeSpan>
    interface IDivisionOperators<TimeSpan, double, TimeSpan>
    interface IDivisionOperators<TimeSpan, TimeSpan, double>
    interface IMinMaxValue<TimeSpan>
    interface IMultiplyOperators<TimeSpan, double, TimeSpan>
    interface IMultiplicativeIdentity<TimeSpan, double>
    interface ISpanParseable<TimeSpan>
    interface IParseable<TimeSpan>
    interface ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>
    interface IUnaryNegationOperators<TimeSpan, TimeSpan>
    interface IUnaryPlusOperators<TimeSpan, TimeSpan>
[<System.Serializable>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
    interface IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), ISpanFormattable
Public Structure TimeSpan
Implements IAdditionOperators(Of TimeSpan, TimeSpan, TimeSpan), IAdditiveIdentity(Of TimeSpan, TimeSpan), IComparable(Of TimeSpan), IComparisonOperators(Of TimeSpan, TimeSpan), IDivisionOperators(Of TimeSpan, Double, TimeSpan), IDivisionOperators(Of TimeSpan, TimeSpan, Double), IEqualityOperators(Of TimeSpan, TimeSpan), IEquatable(Of TimeSpan), IMinMaxValue(Of TimeSpan), IMultiplicativeIdentity(Of TimeSpan, Double), IMultiplyOperators(Of TimeSpan, Double, TimeSpan), IParseable(Of TimeSpan), ISpanFormattable, ISpanParseable(Of TimeSpan), ISubtractionOperators(Of TimeSpan, TimeSpan, TimeSpan), IUnaryNegationOperators(Of TimeSpan, TimeSpan), IUnaryPlusOperators(Of TimeSpan, TimeSpan)
Public Structure TimeSpan
Implements IComparable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan)
繼承
TimeSpan
屬性
實作

範例

下列範例會具現化 物件,代表兩個 TimeSpan 日期之間的差異。 然後,它會顯示 TimeSpan 物件的屬性。

// Define two dates.
DateTime date1 = new DateTime(2010, 1, 1, 8, 0, 15);
DateTime date2 = new DateTime(2010, 8, 18, 13, 30, 30);

// Calculate the interval between the two dates.
TimeSpan interval = date2 - date1;
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString());

// Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays);
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours);
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks);

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000
// Define two dates.
let date1 = DateTime(2010, 1, 1, 8, 0, 15)
let date2 = DateTime(2010, 8, 18, 13, 30, 30)

// Calculate the interval between the two dates.
let interval = date2 - date1
printfn $"{date2} - {date1} = {interval}"

// Display individual properties of the resulting TimeSpan object.
printfn $"""   {"Value of Days Component:",-35} {interval.Days,20}""" 
printfn $"""   {"Total Number of Days:",-35} {interval.TotalDays,20}""" 
printfn $"""   {"Value of Hours Component:",-35} {interval.Hours,20}""" 
printfn $"""   {"Total Number of Hours:",-35} {interval.TotalHours,20}""" 
printfn $"""   {"Value of Minutes Component:",-35} {interval.Minutes,20}""" 
printfn $"""   {"Total Number of Minutes:",-35} {interval.TotalMinutes,20}""" 
printfn $"""   {"Value of Seconds Component:",-35} {interval.Seconds,20:N0}""" 
printfn $"""   {"Total Number of Seconds:",-35} {interval.TotalSeconds,20:N0}""" 
printfn $"""   {"Value of Milliseconds Component:",-35} {interval.Milliseconds,20:N0}""" 
printfn $"""   {"Total Number of Milliseconds:",-35} {interval.TotalMilliseconds,20:N0}""" 
printfn $"""   {"Ticks:",-35} {interval.Ticks,20:N0}""" 

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000
' Define two dates.
Dim date1 As Date = #1/1/2010 8:00:15AM#
Dim date2 As Date = #8/18/2010 1:30:30PM#
' Calculate the interval between the two dates.
Dim interval As TimeSpan = date2 - date1
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString())
' Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays)
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours)
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks)
' The example displays the following output:
'       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
'          Value of Days Component:                             229
'          Total Number of Days:                   229.229340277778
'          Value of Hours Component:                              5
'          Total Number of Hours:                  5501.50416666667
'          Value of Minutes Component:                           30
'          Total Number of Minutes:                       330090.25
'          Value of Seconds Component:                           15
'          Total Number of Seconds:                      19,805,415
'          Value of Milliseconds Component:                       0
'          Total Number of Milliseconds:             19,805,415,000
'          Ticks:                               198,054,150,000,000
# Define two dates.
$Date2 = Get-Date -Date '2010/8/18' -Hour 13 -Minute 30 -Second 30
$Date1 = Get-Date -Date '2010/1/1'  -Hour 8  -Minute 0  -Second 15

# Calculate the interval between the two dates.
$Interval = $Date2 - $Date1
"{0} - {1} = {2}" -f $Date2, $Date1, ($Interval.ToString())

#  Display individual properties of the resulting TimeSpan object.
"   {0,-35} {1,20}"    -f "Value of Days Component:", $Interval.Days
"   {0,-35} {1,20}"    -f "Total Number of Days:", $Interval.TotalDays
"   {0,-35} {1,20}"    -f "Value of Hours Component:", $Interval.Hours
"   {0,-35} {1,20}"    -f "Total Number of Hours:", $Interval.TotalHours
"   {0,-35} {1,20}"    -f "Value of Minutes Component:", $Interval.Minutes
"   {0,-35} {1,20}"    -f "Total Number of Minutes:", $Interval.TotalMinutes
"   {0,-35} {1,20:N0}" -f "Value of Seconds Component:", $Interval.Seconds
"   {0,-35} {1,20:N0}" -f "Total Number of Seconds:", $Interval.TotalSeconds
"   {0,-35} {1,20:N0}" -f "Value of Milliseconds Component:", $Interval.Milliseconds
"   {0,-35} {1,20:N0}" -f "Total Number of Milliseconds:", $Interval.TotalMilliseconds
"   {0,-35} {1,20:N0}" -f "Ticks:", $Interval.Ticks

<# This sample produces the following output:

18/08/2010 13:30:30 - 01/01/2010 08:00:15 = 229.05:30:15
   Value of Days Component:                             229
   Total Number of Days:                   229.229340277778
   Value of Hours Component:                              5
   Total Number of Hours:                  5501.50416666667
   Value of Minutes Component:                           30
   Total Number of Minutes:                       330090.25
   Value of Seconds Component:                           15
   Total Number of Seconds:                      19,805,415
   Value of Milliseconds Component:                       0
   Total Number of Milliseconds:             19,805,415,000
   Ticks:                               198,054,150,000,000
#>

備註

TimeSpan物件代表時間間隔 (持續時間或經過的時間) ,以正數或負數天數、小時、分鐘、秒和秒數來測量。 結構 TimeSpan 也可以用來表示一天的時間,但只有在時間與特定日期無關時才使用。 否則, DateTime 應該改用 或 DateTimeOffset 結構。 (如需使用 TimeSpan 結構來反映當日時間的詳細資訊,請參閱 選擇 DateTime、DateTimeOffset、TimeSpan 和 TimeZoneInfo.)

注意

TimeSpan 代表時間間隔,而且可以表示為特定天數、小時、分鐘、秒和毫秒。 由於它代表一般間隔,而不參考特定起點或終點,因此無法以年份和月份表示,這兩者都有可變天數。 它與值不同 DateTime ,其表示日期和時間,而不參考特定時區,或 DateTimeOffset 代表特定時間點的值。

結構用來測量持續時間的最大時間 TimeSpan 單位是一天。 時間間隔是以天為單位來測量一致性,因為較長時間單位的天數,例如月和年數會有所不同。

物件的值為 TimeSpan 等於所表示時間間隔的刻度數目。 刻度等於 100 奈秒,或一秒的十萬分之一。 物件的值 TimeSpan 可以從 到 TimeSpan.MinValue TimeSpan.MaxValue

具現化 TimeSpan 值

您可以透過數種方式來具現化 TimeSpan 值:

  • 呼叫其隱含無參數建構函式。 這會建立值為 TimeSpan.Zero 的物件,如下列範例所示。

    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".
    
  • 呼叫其中一個明確的建構函式。 下列範例會將 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".
    
  • 呼叫 方法或執行傳回 TimeSpan 值的作業。 例如,您可以具現化代表兩個 TimeSpan 日期和時間值之間間隔的值,如下列範例所示。

    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
    

    您也可以以此方式將 物件初始化 TimeSpan 為零時間值,如下列範例所示。

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

    TimeSpan值是由 、 DateTimeOffsetTimeSpan 結構的算術運算子和方法 DateTime 傳回。

  • 藉由剖析值的字串表示 TimeSpan 。 您可以使用 ParseTryParse 方法,將包含時間間隔的 TimeSpan 字串轉換成值。 下列範例會 Parse 使用 方法,將字串陣列轉換成 TimeSpan 值。

    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'
    

    此外,您可以呼叫 ParseExactTryParseExact 方法,定義要剖析並轉換成 TimeSpan 值的輸入字串精確格式。

在 TimeSpan 值上執行作業

您可以使用 和 運算子,或呼叫 AddSubtraction Subtract 方法來加入和減去時間持續時間 Addition 。 您也可以藉由呼叫 CompareCompareToEquals 方法來比較兩個持續時間。 結構 TimeSpan 也包含 DurationNegate 方法,可將時間間隔轉換為正值和負值。

值的範圍 TimeSpanMinValueMaxValue

格式化 TimeSpan 值

TimeSpan 可以表示為 [ - ]dhhmmssff,其中選擇性減號表示負時間間隔, d 元件是天, hh 是以 24 小時制測量的小時, mm 是分鐘, ss 是秒,而 ff 是秒的分數。 也就是說,時間間隔是由沒有一天時間的正數或負數天所組成,或是包含一天時間的天數,或只包含一天的時間。

從 .NET Framework 4 開始,結構 TimeSpan 透過 方法 ToString 的多載支援區分文化特性的格式,以將值轉換成 TimeSpan 其字串表示。 預設 TimeSpan.ToString() 方法會使用與舊版.NET Framework中的傳回值完全相同的不變異格式,傳回時間間隔。 多 TimeSpan.ToString(String) 載可讓您指定格式字串,以定義時間間隔的字串表示。 多 TimeSpan.ToString(String, IFormatProvider) 載可讓您指定格式字串以及其格式慣例用來建立時間間隔字串表示的文化特性。 TimeSpan 支援標準和自訂格式字串。 (如需詳細資訊,請參閱 標準 TimeSpan 格式字串自訂 TimeSpan 格式 Strings.) 不過,只有標準格式字串會區分文化特性。

還原舊版 TimeSpan 格式設定

在某些情況下,.NET Framework 3.5 和舊版中成功格式化 TimeSpan 值的程式碼會在 .NET Framework 4 中失敗。 這在程式碼中最常呼叫 <TimeSpan_LegacyFormatMode> 元素 方法,以使用格式字串格式化 TimeSpan 值。 下列範例成功格式化 TimeSpan .NET Framework 3.5 和較舊版本中的值,但在 .NET Framework 4 和更新版本中擲回例外狀況。 請注意,它會嘗試使用不支援的格式規範來格式化 TimeSpan 值,這會在 .NET Framework 3.5 和舊版中忽略。

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

如果您無法修改程式碼,您可以使用下列其中一種方式還原值的舊版格式 TimeSpan 設定:

  • 藉由建立包含 <TimeSpan_LegacyFormatMode> 專案的組態檔。 將這個專案的 enabled 屬性設定為 true 會以個別應用程式為基礎還原舊版 TimeSpan 格式設定。

  • 當您建立應用程式域時,藉由設定 「NetFx40_TimeSpanLegacyFormatMode」 相容性參數。 這會根據每個應用程式域啟用舊版 TimeSpan 格式設定。 下列範例會建立使用舊版 TimeSpan 格式設定的應用程式域。

    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
    

    當下列程式碼在新的應用程式域中執行時,它會還原為舊版 TimeSpan 格式設定行為。

    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.
    

建構函式

TimeSpan(Int32, Int32, Int32)

TimeSpan 結構的新執行個體初始化為指定的時數、分鐘數和秒數。

TimeSpan(Int32, Int32, Int32, Int32)

TimeSpan 結構的新執行個體初始化為指定的天數、時數、分鐘數和秒數。

TimeSpan(Int32, Int32, Int32, Int32, Int32)

TimeSpan 結構的新執行個體初始化為指定的天數、時數、分鐘數、秒數和毫秒數。

TimeSpan(Int64)

TimeSpan 結構的新執行個體初始化為刻度的指定數目。

欄位

MaxValue

代表最大 TimeSpan 值。 此欄位為唯讀。

MinValue

代表最小 TimeSpan 值。 此欄位為唯讀。

TicksPerDay

表示 1 天中的刻度數。 這個欄位為常數。

TicksPerHour

表示 1 小時中的刻度數。 這個欄位為常數。

TicksPerMillisecond

表示 1 毫秒中的刻度數。 這個欄位為常數。

TicksPerMinute

表示 1 分鐘中的刻度數。 這個欄位為常數。

TicksPerSecond

表示 1 秒中的刻度數。

Zero

代表零 TimeSpan 值。 此欄位為唯讀。

屬性

Days

取得目前 TimeSpan 結構所表示之時間間隔的天數元件。

Hours

取得目前 TimeSpan 結構所表示之時間間隔的時數元件。

Milliseconds

取得目前 TimeSpan 結構所表示之時間間隔的毫秒數元件。

Minutes

取得目前 TimeSpan 結構所表示之時間間隔的分鐘數元件。

Seconds

取得目前 TimeSpan 結構所表示之時間間隔的秒數元件。

Ticks

取得刻度數,表示目前 TimeSpan 結構的值。

TotalDays

取得目前 TimeSpan 結構的值,這個值以整數和小數的天數表示。

TotalHours

取得目前 TimeSpan 結構的值,這個值以整數和小數的時數表示。

TotalMilliseconds

取得目前 TimeSpan 結構的值,這個值以整數和小數的毫秒數表示。

TotalMinutes

取得目前 TimeSpan 結構的值,這個值以整數和小數的分鐘數表示。

TotalSeconds

取得目前 TimeSpan 結構的值,這個值以整數和小數的秒數表示。

方法

Add(TimeSpan)

傳回新的 TimeSpan 物件,它的值為指定之 TimeSpan 物件與這個執行個體的總和。

Compare(TimeSpan, TimeSpan)

比較兩個 TimeSpan 值並傳回整數,這個整數會指出第一個值比第二個值短、等長或較長。

CompareTo(Object)

比較這個執行個體和指定的物件,並傳回一個整數,表示這個執行個體短於、等於或長於指定的物件。

CompareTo(TimeSpan)

比較這個執行個體和指定的 TimeSpan 物件,並傳回一個整數,表示這個執行個體短於、等於或長於 TimeSpan 物件。

Divide(Double)

傳回新的 TimeSpan 物件,其值為此執行個體與指定 divisor 相除後的結果。

Divide(TimeSpan)

傳回新的 Double 值,其為此執行個體與指定 ts 相除後的結果。

Duration()

傳回新的 TimeSpan 物件,其值為目前 TimeSpan 物件的絕對值。

Equals(Object)

傳回值,該值表示這個執行個體是否和指定的物件相等。

Equals(TimeSpan)

傳回表示這個執行個體是否等於指定 TimeSpan 物件的值。

Equals(TimeSpan, TimeSpan)

傳回值,這個值表示兩個指定的 TimeSpan 執行個體是否相等。

FromDays(Double)

傳回表示指定天數的 TimeSpan,其規格的精確度達到最接近的毫秒數。

FromHours(Double)

傳回表示指定時數的 TimeSpan,其規格的精確度達到最接近的毫秒數。

FromMilliseconds(Double)

傳回表示指定毫秒數的 TimeSpan

FromMinutes(Double)

傳回表示指定分鐘數的 TimeSpan,其規格的精確度達到最接近的毫秒數。

FromSeconds(Double)

傳回表示指定秒數的 TimeSpan,其規格的精確度達到最接近的毫秒數。

FromTicks(Int64)

傳回表示指定時間的 TimeSpan,其規格是以刻度為單位。

GetHashCode()

傳回這個執行個體的雜湊碼。

Multiply(Double)

傳回新的 TimeSpan 物件,其值是此執行個體與指定 factor 相乘後的結果。

Negate()

傳回新 TimeSpan 物件,其值是這個執行個體的相反值。

Parse(ReadOnlySpan<Char>, IFormatProvider)

使用指定的特定文化特性格式資訊,將時間間隔的範圍表示轉換為其對等的 TimeSpan

Parse(String)

將時間間隔的字串表示,轉換成與其相等的 TimeSpan

Parse(String, IFormatProvider)

使用指定的特定文化特性格式資訊,將時間間隔的字串表示轉換為其相等的 TimeSpan

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

使用指定格式和特定文化特性格式資訊,將時間間隔的字元範圍轉換為其對等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。

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

使用指定之格式、特定文件特性格式資訊和樣式,將時間間隔的字串表示轉換為其相等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。

ParseExact(String, String, IFormatProvider)

使用指定之格式和特定文化特性格式資訊,將時間間隔的字串表示轉換為其相等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

使用指定之格式、特定文件特性格式資訊和樣式,將時間間隔的字串表示轉換為其相等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。

ParseExact(String, String[], IFormatProvider)

使用指定之格式字串的陣列和特定文件特性格式資訊,將時間間隔的字串表示轉換為其相等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

使用指定之格式、特定文件特性格式資訊和樣式,將時間間隔的字串表示轉換為其相等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。

Subtract(TimeSpan)

傳回新的 TimeSpan 物件,它的值為指定之 TimeSpan 物件與這個執行個體的差。

ToString()

將目前 TimeSpan 物件的值,轉換為其相等的字串表示。

ToString(String)

使用指定的格式,將目前 TimeSpan 物件的值,轉換為其相等字串表示。

ToString(String, IFormatProvider)

使用指定的格式和特定文件特性格式資訊,將目前 TimeSpan 物件的值,轉換為其相等的字串表示。

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

嘗試將目前時間範圍數字執行個體的值格式化為所提供的字元範圍。

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

使用指定的特定文件特性格式資訊,將時間間隔的範圍表示轉換為其對等的 TimeSpan,並傳回值以指出轉換是否成功。

TryParse(ReadOnlySpan<Char>, TimeSpan)

將時間間隔的範圍表示轉換為其對等的 TimeSpan,並傳回值以指出轉換是否成功。

TryParse(String, IFormatProvider, TimeSpan)

使用指定的特定文件特性格式資訊,將時間間隔的字串表示轉換為其相等的 TimeSpan,並傳回表示轉換是否成功的值。

TryParse(String, TimeSpan)

將時間間隔的字串表示,轉換為其相等的 TimeSpan,並傳回一個值表示轉換是否成功。

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

使用指定的格式和文化特性專屬格式資訊,將時間間隔的指定範圍表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。

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

使用指定格式、特定文件特性格式資訊及樣式,將指定的時間間隔範圍表示轉換為其對等的 TimeSpan,並傳回值以指出轉換是否成功。 字串表示的格式必須完全符合指定的格式。

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

使用指定的格式和文化特性專屬格式資訊,將時間間隔的指定範圍表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。

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

使用指定的格式、文化特性專屬格式資訊及樣式,將時間間隔的指定範圍表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。

TryParseExact(String, String, IFormatProvider, TimeSpan)

使用指定之格式和特定文化特性格式資訊,將時間間隔的字串表示轉換為其相等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。

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

使用指定的格式、文化特性專屬格式資訊及樣式,將時間間隔的指定字串表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合指定的格式。

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

使用指定的格式和文化特性專屬格式資訊,將時間間隔的指定字串表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。

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

使用指定的格式、文化特性專屬格式資訊及樣式,將時間間隔的指定字串表示法轉換成對等的 TimeSpan。 字串表示的格式必須完全符合其中一個指定的格式。

運算子

Addition(TimeSpan, TimeSpan)

加入兩個指定的 TimeSpan 執行個體。

Division(TimeSpan, Double)

傳回新的 TimeSpan 物件,其值為 timeSpan 執行個體與指定 divisor 相除後的結果。

Division(TimeSpan, TimeSpan)

傳回新的 Double 值,其為 t1 執行個體與指定 t2 相除後的結果。

Equality(TimeSpan, TimeSpan)

表示兩個 TimeSpan 執行個體是否相等。

GreaterThan(TimeSpan, TimeSpan)

表示指定的 TimeSpan 是否大於另一個指定的 TimeSpan

GreaterThanOrEqual(TimeSpan, TimeSpan)

表示指定的 TimeSpan 是否大於或等於另一個指定的 TimeSpan

Inequality(TimeSpan, TimeSpan)

表示兩個 TimeSpan 執行個體是否不相等。

LessThan(TimeSpan, TimeSpan)

表示指定的 TimeSpan 是否小於另一個指定的 TimeSpan

LessThanOrEqual(TimeSpan, TimeSpan)

表示指定的 TimeSpan 是否小於或等於另一個指定的 TimeSpan

Multiply(Double, TimeSpan)

傳回新的 TimeSpan 物件,其值是指定的 factor 與指定的 timeSpan 執行個體相乘後的結果。

Multiply(TimeSpan, Double)

傳回新的 TimeSpan 物件,其值是指定的 timeSpan 執行個體與指定 factor 相乘後的結果。

Subtraction(TimeSpan, TimeSpan)

將指定的 TimeSpan 從另一個指定的 TimeSpan 減掉。

UnaryNegation(TimeSpan)

傳回 TimeSpan,其值是指定執行個體的相反值。

UnaryPlus(TimeSpan)

傳回 TimeSpan 的指定執行個體。

明確介面實作

IComparable.CompareTo(Object)

比較這個執行個體和指定的物件,並傳回一個整數,表示這個執行個體短於、等於或長於指定的物件。

適用於

另請參閱