TimeSpan Struktura

Definicja

Reprezentuje interwał czasu.

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)
Dziedziczenie
TimeSpan
Atrybuty
Implementuje

Przykłady

Poniższy przykład tworzy wystąpienie obiektu, który reprezentuje różnicę TimeSpan między dwiema datami. Następnie wyświetla TimeSpan właściwości obiektu.

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

Uwagi

TimeSpan Obiekt reprezentuje interwał czasu (czas trwania czasu lub czas, który upłynął) mierzony jako dodatnia lub ujemna liczba dni, godzin, minut, sekund i ułamków sekundy. Struktura TimeSpan może również służyć do reprezentowania godziny dnia, ale tylko wtedy, gdy czas nie ma związku z określoną datą. DateTime W przeciwnym razie należy zamiast tego użyć struktury lubDateTimeOffset. (Aby uzyskać więcej informacji na temat używania TimeSpan struktury do odzwierciedlenia godziny dnia, zobacz Wybieranie między datetime, DateTimeOffset, TimeSpan i TimeZoneInfo).

Uwaga

TimeSpan Wartość reprezentuje interwał czasu i może być wyrażona jako określona liczba dni, godzin, minut, sekund i milisekund. Ponieważ reprezentuje ogólny interwał bez odwołania do określonego punktu początkowego lub końcowego, nie można go wyrazić w kategoriach lat i miesięcy, z których obie mają zmienną liczbę dni. Różni się od DateTime wartości, która reprezentuje datę i godzinę bez odwołania do określonej strefy czasowej lub DateTimeOffset wartość, która reprezentuje określony moment czasu.

Największa jednostka czasu używana TimeSpan przez strukturę do mierzenia czasu trwania to dzień. Interwały czasu są mierzone w dniach spójności, ponieważ liczba dni w większych jednostkach czasu, takich jak miesiące i lata, różni się.

Wartość TimeSpan obiektu to liczba znaczników, które są równe reprezentowanym interwałowi czasu. Kleszcz jest równy 100 nanosekundom lub dziesiątej części sekundy. Wartość TimeSpan obiektu może wahać się od TimeSpan.MinValue do TimeSpan.MaxValue.

Utworzenie wystąpienia wartości TimeSpan

Możesz utworzyć TimeSpan wystąpienie wartości na wiele sposobów:

  • Wywołując niejawny konstruktor bez parametrów. Spowoduje to utworzenie obiektu, którego wartość to TimeSpan.Zero, jak pokazano w poniższym przykładzie.

    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".
    
  • Wywołując jeden z jego jawnych konstruktorów. Poniższy przykład inicjuje TimeSpan wartość do określonej liczby godzin, minut i sekund.

    TimeSpan interval = new TimeSpan(2, 14, 18);
    Console.WriteLine(interval.ToString());              
    
    // Displays "02:14:18".
    
    let interval = TimeSpan(2, 14, 18)
    printfn $"{interval}"              
    
    // Displays "02:14:18".
    
    Dim interval As New TimeSpan(2, 14, 18)
    Console.WriteLine(interval.ToString())                ' Displays "02:14:18".
    
  • Wywołując metodę lub wykonując operację zwracającą TimeSpan wartość. Na przykład można utworzyć wystąpienie TimeSpan wartości reprezentującej interwał między dwiema wartościami daty i godziny, jak pokazano w poniższym przykładzie.

    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
    

    W ten sposób można również zainicjować TimeSpan obiekt na wartość zero czasu, jak pokazano w poniższym przykładzie.

       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 wartości są zwracane przez operatory arytmetyczne i metody DateTimestruktur , DateTimeOffseti TimeSpan .

  • Analizowanie reprezentacji TimeSpan ciągu wartości. Metody i TryParse umożliwiają Parse konwertowanie ciągów zawierających interwały czasowe na TimeSpan wartości. W poniższym przykładzie Parse użyto metody , aby przekonwertować tablicę ciągów na TimeSpan wartości.

    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'
    

    Ponadto można zdefiniować dokładny format ciągu wejściowego, który ma być analizowany i konwertowany na wartość, wywołując ParseExact metodę TimeSpan orTryParseExact.

Wykonywanie operacji na wartościach TimeSpan

Czas trwania można dodawać i odejmować przy użyciu Addition operatorów i Subtraction lub wywołując Add metody i Subtract . Można również porównać dwa czasy, wywołując Comparemetody , CompareToi Equals . Struktura TimeSpan obejmuje Duration również metody i Negate , które konwertują interwały czasu na wartości dodatnie i ujemne,

Zakres TimeSpan wartości to MinValue MaxValue.

Formatowanie wartości TimeSpan

Wartość TimeSpan może być reprezentowana jako [-]d.hh:mm:ss. ff, gdzie opcjonalny znak minus wskazuje ujemny interwał czasu, składnik d to dni, hh jest godzinami mierzonymi na zegarze 24-godzinnym, mm to minuty, ss to sekundy, a ff jest ułamkami sekundy. Oznacza to, że interwał czasu składa się z dodatniej lub ujemnej liczby dni bez godziny dnia lub liczby dni z godziną dnia lub tylko raz dziennie.

Począwszy od .NET Framework 4, TimeSpan struktura obsługuje formatowanie wrażliwe na kulturę przez przeciążenia metodyToString, która konwertuje wartość na reprezentację TimeSpan ciągu. Metoda domyślna TimeSpan.ToString() zwraca interwał czasu przy użyciu niezmiennego formatu, który jest identyczny z wartością zwracaną w poprzednich wersjach .NET Framework. Przeciążenie TimeSpan.ToString(String) umożliwia określenie ciągu formatu definiującego reprezentację ciągu interwału czasu. Przeciążenie TimeSpan.ToString(String, IFormatProvider) umożliwia określenie ciągu formatu i kultury, której konwencje formatowania są używane do tworzenia reprezentacji ciągu interwału czasu. TimeSpan obsługuje zarówno ciągi formatu standardowego, jak i niestandardowego. (Aby uzyskać więcej informacji, zobacz Ciągi formatu TimeSpan w warstwie Standardowa i niestandardowe ciągi formatu TimeSpan). Jednak tylko standardowe ciągi formatu są wrażliwe na kulturę.

Przywracanie starszego formatowania TimeSpan

W niektórych przypadkach kod, który pomyślnie formatuje TimeSpan wartości w .NET Framework 3.5 i starszych wersjach, kończy się niepowodzeniem w .NET Framework 4. Jest to najczęściej spotykane w kodzie, który wywołuje metodę elementu<TimeSpan_LegacyFormatMode> w celu sformatowania TimeSpan wartości za pomocą ciągu formatu. Poniższy przykład pomyślnie formatuje TimeSpan wartość w wersji .NET Framework 3.5 i starszych, ale zgłasza wyjątek w wersji .NET Framework 4 i nowszych. Należy pamiętać, że próbuje sformatować TimeSpan wartość przy użyciu nieobsługiwanego specyfikatora formatu, który jest ignorowany w .NET Framework 3.5 i starszych wersjach.

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

Jeśli nie możesz zmodyfikować kodu, możesz przywrócić starsze formatowanie TimeSpan wartości na jeden z następujących sposobów:

  • Tworząc plik konfiguracji zawierający element<TimeSpan_LegacyFormatMode>. Ustawienie atrybutu enabled tego elementu w celu true przywrócenia starszego TimeSpan formatowania na podstawie aplikacji.

  • Ustawiając przełącznik zgodności "NetFx40_TimeSpanLegacyFormatMode" podczas tworzenia domeny aplikacji. Umożliwia to starsze TimeSpan formatowanie na podstawie domeny aplikacji. Poniższy przykład tworzy domenę aplikacji, która używa starszego TimeSpan formatowania.

    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
    

    Gdy poniższy kod zostanie wykonany w nowej domenie aplikacji, zostanie przywrócony do starszego TimeSpan zachowania formatowania.

    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.
    

Konstruktory

TimeSpan(Int32, Int32, Int32)

Inicjuje TimeSpan nowe wystąpienie struktury do określonej liczby godzin, minut i sekund.

TimeSpan(Int32, Int32, Int32, Int32)

Inicjuje TimeSpan nowe wystąpienie struktury do określonej liczby dni, godzin, minut i sekund.

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

Inicjuje TimeSpan nowe wystąpienie struktury do określonej liczby dni, godzin, minut, sekund i milisekund.

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

Inicjuje TimeSpan nowe wystąpienie struktury do określonej liczby dni, godzin, minut, sekund i milisekund.

TimeSpan(Int64)

Inicjuje TimeSpan nowe wystąpienie struktury do określonej liczby kleszczy.

Pola

MaxValue

Reprezentuje wartość maksymalną TimeSpan . To pole jest tylko do odczytu.

MinValue

Reprezentuje wartość minimalną TimeSpan . To pole jest tylko do odczytu.

NanosecondsPerTick

Reprezentuje liczbę nanosekund na kleszcz. To pole jest stałe.

TicksPerDay

Reprezentuje liczbę kleszczy w ciągu 1 dnia. To pole jest stałe.

TicksPerHour

Reprezentuje liczbę kleszczy w ciągu 1 godziny. To pole jest stałe.

TicksPerMicrosecond

Reprezentuje liczbę kleszczy w 1 mikrosekundach. To pole jest stałe.

TicksPerMillisecond

Przedstawia liczbę znaczników w milisekundach. To pole jest stałe.

TicksPerMinute

Reprezentuje liczbę znaczników w ciągu 1 minuty. To pole jest stałe.

TicksPerSecond

Reprezentuje liczbę znaczników w ciągu 1 sekundy.

Zero

Reprezentuje wartość zero TimeSpan . To pole jest tylko do odczytu.

Właściwości

Days

Pobiera składnik dni interwału czasu reprezentowanego przez bieżącą TimeSpan strukturę.

Hours

Pobiera składnik godzin interwału czasu reprezentowanego przez bieżącą TimeSpan strukturę.

Microseconds

Pobiera składnik mikrosekund interwału czasu reprezentowanego przez bieżącą TimeSpan strukturę.

Milliseconds

Pobiera składnik milisekund interwału czasu reprezentowanego przez bieżącą TimeSpan strukturę.

Minutes

Pobiera składnik minut interwału czasu reprezentowanego przez bieżącą TimeSpan strukturę.

Nanoseconds

Pobiera składnik nanosekund interwału czasu reprezentowanego przez bieżącą TimeSpan strukturę.

Seconds

Pobiera składnik sekund interwału czasu reprezentowanego przez bieżącą TimeSpan strukturę.

Ticks

Pobiera liczbę znaczników reprezentujących wartość bieżącej TimeSpan struktury.

TotalDays

Pobiera wartość bieżącej TimeSpan struktury wyrażonej w dniach całkowitych i ułamkowych.

TotalHours

Pobiera wartość bieżącej TimeSpan struktury wyrażonej w godzinach całkowitych i ułamkowych.

TotalMicroseconds

Pobiera wartość bieżącej TimeSpan struktury wyrażonej w mikrosekundach całkowitych i ułamkowych.

TotalMilliseconds

Pobiera wartość bieżącej TimeSpan struktury wyrażonej w milisekundach całkowitych i ułamkowych.

TotalMinutes

Pobiera wartość bieżącej TimeSpan struktury wyrażonej w minutach całkowitych i ułamkowych.

TotalNanoseconds

Pobiera wartość bieżącej TimeSpan struktury wyrażonej w całości i ułamkowych nanosekundach.

TotalSeconds

Pobiera wartość bieżącej TimeSpan struktury wyrażonej w sekundach całkowitych i ułamkowych.

Metody

Add(TimeSpan)

Zwraca nowy TimeSpan obiekt, którego wartość jest sumą określonego TimeSpan obiektu i tego wystąpienia.

Compare(TimeSpan, TimeSpan)

Porównuje dwie TimeSpan wartości i zwraca liczbę całkowitą wskazującą, czy pierwsza wartość jest krótsza niż, równa, czy dłuższa niż druga wartość.

CompareTo(Object)

Porównuje to wystąpienie z określonym obiektem i zwraca liczbę całkowitą wskazującą, czy to wystąpienie jest krótsze niż, równe lub dłuższe niż określony obiekt.

CompareTo(TimeSpan)

Porównuje to wystąpienie z określonym TimeSpan obiektem i zwraca liczbę całkowitą wskazującą, czy to wystąpienie jest krótsze niż, równe, czy dłuższe niż TimeSpan obiekt.

Divide(Double)

Zwraca nowy TimeSpan obiekt, który jest wynikiem dzielenia tego wystąpienia i określonego divisorobiektu .

Divide(TimeSpan)

Zwraca nową Double wartość, która jest wynikiem dzielenia tego wystąpienia i określonej wartości ts.

Duration()

Zwraca nowy TimeSpan obiekt, którego wartość jest wartością bezwzględną bieżącego TimeSpan obiektu.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.

Equals(TimeSpan)

Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu TimeSpan obiektowi.

Equals(TimeSpan, TimeSpan)

Zwraca wartość wskazującą, czy dwa określone wystąpienia są TimeSpan równe.

FromDays(Double)

Zwraca wartość TimeSpan reprezentującą określoną liczbę dni, w której specyfikacja jest dokładna do najbliższej milisekundy.

FromHours(Double)

Zwraca wartość TimeSpan , która reprezentuje określoną liczbę godzin, gdzie specyfikacja jest dokładna do najbliższej milisekundy.

FromMicroseconds(Double)

Zwraca wartość , TimeSpan która reprezentuje określoną liczbę mikrosekund.

FromMilliseconds(Double)

Zwraca wartość TimeSpan reprezentującą określoną liczbę milisekund.

FromMinutes(Double)

Zwraca wartość TimeSpan reprezentującą określoną liczbę minut, gdzie specyfikacja jest dokładna dla najbliższej milisekundy.

FromSeconds(Double)

Zwraca wartość TimeSpan reprezentującą określoną liczbę sekund, gdzie specyfikacja jest dokładna dla najbliższej milisekundy.

FromTicks(Int64)

Zwraca wartość , TimeSpan która reprezentuje określony czas, gdzie specyfikacja jest wyrażona w jednostkach kleszczy.

GetHashCode()

Zwraca kod skrótu dla tego wystąpienia.

Multiply(Double)

Zwraca nowy TimeSpan obiekt, który jest wynikiem mnożenia tego wystąpienia i określonej wartości factor.

Negate()

Zwraca nowy TimeSpan obiekt, którego wartość jest negowaną wartością tego wystąpienia.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Konwertuje reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonych informacji o formacie specyficznym dla kultury.

Parse(String)

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik.

Parse(String, IFormatProvider)

Konwertuje reprezentację ciągu interwału czasu na odpowiednik TimeSpan przy użyciu określonych informacji o formacie specyficznym dla kultury.

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

Konwertuje przedział czasu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów, informacji o formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

ParseExact(String, String, IFormatProvider)

Konwertuje reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

ParseExact(String, String[], IFormatProvider)

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonej tablicy ciągów formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

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

Konwertuje reprezentację ciągu interwału czasu na TimeSpan odpowiednik przy użyciu określonych formatów, informacji o formacie specyficznym dla kultury i stylów. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

Subtract(TimeSpan)

Zwraca nowy TimeSpan obiekt, którego wartość jest różnicą między określonym TimeSpan obiektem a tym wystąpieniem.

ToString()

Konwertuje wartość bieżącego TimeSpan obiektu na równoważną reprezentację ciągu.

ToString(String)

Konwertuje wartość bieżącego TimeSpan obiektu na równoważną reprezentację ciągu przy użyciu określonego formatu.

ToString(String, IFormatProvider)

Konwertuje wartość bieżącego TimeSpan obiektu na równoważną reprezentację ciągu przy użyciu określonych formatów i informacji o formatowaniu specyficznym dla kultury.

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

Próbuje sformatować wartość bieżącego wystąpienia liczby przedziału czasu w podanym zakresie znaków.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Konwertuje reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonych informacji formatowania specyficznych dla kultury i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Konwertuje reprezentację przedziału czasu na TimeSpan odpowiednik i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

TryParse(String, IFormatProvider, TimeSpan)

Konwertuje reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonych informacji formatowania specyficznych dla kultury i zwraca wartość wskazującą, czy konwersja powiodła się.

TryParse(String, TimeSpan)

Konwertuje reprezentację ciągu interwału czasu na TimeSpan odpowiednik i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

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

Konwertuje określoną reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Konwertuje określoną reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonego formatu, informacji o formacie specyficznym dla kultury i stylów oraz zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Konwertuje określoną reprezentację przedziału czasu na równoważne TimeSpan przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

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

Konwertuje określoną reprezentację przedziału czasu na odpowiednik TimeSpan przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

TryParseExact(String, String, IFormatProvider, TimeSpan)

Konwertuje reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Konwertuje reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonego formatu, informacji i stylów formatu specyficznego dla kultury. Format ciągu reprezentującego musi dokładnie pasować do wskazanego formatu.

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

Konwertuje określoną reprezentację ciągu przedziału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów i informacji o formacie specyficznym dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

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

Konwertuje określoną reprezentację ciągu interwału czasu na jego TimeSpan odpowiednik przy użyciu określonych formatów, informacji i stylów formatu specyficznego dla kultury. Format ciągu reprezentującego musi dokładnie pasować do jednego ze wskazanych formatów.

Operatory

Addition(TimeSpan, TimeSpan)

Dodaje dwa określone TimeSpan wystąpienia.

Division(TimeSpan, Double)

Zwraca nowy TimeSpan obiekt, który jest wynikiem dzielenia timeSpan wystąpienia i określonego divisorobiektu .

Division(TimeSpan, TimeSpan)

Zwraca nową Double wartość, która jest wynikiem dzielenia t1 wystąpienia i określonej wartości t2.

Equality(TimeSpan, TimeSpan)

Wskazuje, czy dwa TimeSpan wystąpienia są równe.

GreaterThan(TimeSpan, TimeSpan)

Wskazuje, czy określony TimeSpan element jest większy niż inny określony TimeSpan.

GreaterThanOrEqual(TimeSpan, TimeSpan)

Wskazuje, czy określony TimeSpan element jest większy niż lub równy innemu określonemu TimeSpan.

Inequality(TimeSpan, TimeSpan)

Wskazuje, czy dwa TimeSpan wystąpienia nie są równe.

LessThan(TimeSpan, TimeSpan)

Wskazuje, czy określona wartość TimeSpan jest mniejsza niż inna określona TimeSpanwartość .

LessThanOrEqual(TimeSpan, TimeSpan)

Wskazuje, czy określona wartość TimeSpan jest mniejsza niż lub równa innej określonej TimeSpan.

Multiply(Double, TimeSpan)

Zwraca nowy TimeSpan obiekt, którego wartość jest wynikiem mnożenia określonego factor i określonego timeSpan wystąpienia.

Multiply(TimeSpan, Double)

Zwraca nowy TimeSpan obiekt, którego wartość jest wynikiem mnożenia określonego timeSpan wystąpienia i określonego factorobiektu .

Subtraction(TimeSpan, TimeSpan)

Odejmuje określony TimeSpan element z innego określonego elementu TimeSpan.

UnaryNegation(TimeSpan)

TimeSpan Zwraca wartość, której wartość jest negowaną wartością określonego wystąpienia.

UnaryPlus(TimeSpan)

Zwraca określone wystąpienie klasy TimeSpan.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje to wystąpienie z określonym obiektem i zwraca liczbę całkowitą wskazującą, czy to wystąpienie jest krótsze niż, równe lub dłuższe niż określony obiekt.

Dotyczy

Zobacz też