TimeSpan Struktura

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

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: Object

ValueType
TimeSpan

Atrybuty: SerializableAttribute ComVisibleAttribute

Implementuje: IComparable IComparable<TimeSpan> IEquatable<TimeSpan> IFormattable ISpanFormattable IParsable<TimeSpan> IParsable<TSelf> ISpanParsable<TimeSpan>

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 `divisor`obiektu .
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 `divisor`obiektu .
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 `factor`obiektu .
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