TimeSpan Structure

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente un intervalle de temps.

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)

Héritage: Object

ValueType
TimeSpan

Attributs: SerializableAttribute ComVisibleAttribute

Implémente: IComparable IComparable<TimeSpan> IEquatable<TimeSpan> IFormattable ISpanFormattable IParsable<TimeSpan> IParsable<TSelf> ISpanParsable<TimeSpan>

Exemples

L’exemple suivant instancie un TimeSpan objet qui représente la différence entre deux dates. Il affiche ensuite les propriétés de l’objet 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
#>

Remarques

Un TimeSpan objet représente un intervalle de temps (durée ou temps écoulé) qui est mesuré sous la forme d’un nombre positif ou négatif de jours, d’heures, de minutes, de secondes et de fractions de seconde. La TimeSpan structure peut également être utilisée pour représenter l’heure de la journée, mais uniquement si l’heure n’est pas liée à une date particulière. Sinon, la DateTime structure ou DateTimeOffset doit être utilisée à la place. (Pour plus d’informations sur l’utilisation de la TimeSpan structure pour refléter l’heure de la journée, consultez Choix entre DateTime, DateTimeOffset, TimeSpan et TimeZoneInfo.)

Notes

Une TimeSpan valeur représente un intervalle de temps et peut être exprimée sous la forme d’un nombre particulier de jours, d’heures, de minutes, de secondes et de millisecondes. Étant donné qu’il représente un intervalle général sans référence à un point de départ ou de fin particulier, il ne peut pas être exprimé en termes d’années et de mois, qui ont tous deux un nombre variable de jours. Il diffère d’une DateTime valeur, qui représente une date et une heure sans référence à un fuseau horaire particulier, ou d’une DateTimeOffset valeur, qui représente un moment spécifique de l’heure.

La plus grande unité de temps que la structure utilise pour mesurer la TimeSpan durée est une journée. Les intervalles de temps sont mesurés en jours à des fins de cohérence, car le nombre de jours dans des unités de temps plus grandes, telles que des mois et des années, varie.

La valeur d’un TimeSpan objet est le nombre de graduations qui sont égales à l’intervalle de temps représenté. Une graduation est égale à 100 nanosecondes, soit un dix millionième de seconde. La valeur d’un TimeSpan objet peut aller de TimeSpan.MinValue à TimeSpan.MaxValue.

Instanciation d’une valeur TimeSpan

Vous pouvez instancier une TimeSpan valeur de plusieurs façons :

En appelant son constructeur implicite sans paramètre. Cela crée un objet dont la valeur est TimeSpan.Zero, comme le montre l’exemple suivant.

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

En appelant l’un de ses constructeurs explicites. L’exemple suivant initialise une TimeSpan valeur à un nombre spécifié d’heures, de minutes et de secondes.

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

En appelant une méthode ou en effectuant une opération qui retourne une TimeSpan valeur. Par exemple, vous pouvez instancier une TimeSpan valeur qui représente l’intervalle entre deux valeurs de date et d’heure, comme le montre l’exemple suivant.

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

Vous pouvez également initialiser un TimeSpan objet à une valeur de temps zéro de cette façon, comme le montre l’exemple suivant.

   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 les valeurs sont retournées par des opérateurs arithmétiques et des méthodes des DateTimestructures , DateTimeOffsetet TimeSpan .

En analysant la représentation sous forme de chaîne d’une TimeSpan valeur. Vous pouvez utiliser les Parse méthodes et TryParse pour convertir des chaînes qui contiennent des intervalles de temps en TimeSpan valeurs. L’exemple suivant utilise la Parse méthode pour convertir un tableau de chaînes en TimeSpan valeurs.

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'

En outre, vous pouvez définir le format précis de la chaîne d’entrée à analyser et à convertir en valeur TimeSpan en appelant la ParseExact méthode ou TryParseExact .

Exécution d’opérations sur des valeurs TimeSpan

Vous pouvez ajouter et soustraire des durées de temps à l’aide Addition des opérateurs et Subtraction ou en appelant les Add méthodes et Subtract . Vous pouvez également comparer deux durées de temps en appelant les Compareméthodes , CompareToet Equals . La TimeSpan structure inclut également les Duration méthodes et Negate , qui convertissent les intervalles de temps en valeurs positives et négatives,

La plage de TimeSpan valeurs est MinValue de MaxValue.

Mise en forme d’une valeur TimeSpan

Une TimeSpan valeur peut être représentée par [-]d. hh:mm:ss. ff, où le signe moins facultatif indique un intervalle de temps négatif, le composant d est jours, hh est des heures mesurées sur une horloge de 24 heures, mm est minutes, ss est secondes et ff est des fractions de seconde. Autrement dit, un intervalle de temps se compose d’un nombre positif ou négatif de jours sans heure de la journée, ou d’un nombre de jours avec une heure de la journée, ou seulement une heure de la journée.

À compter de .NET Framework 4, la structure prend en charge la TimeSpan mise en forme sensible à la culture via les surcharges de sa ToString méthode, qui convertit une TimeSpan valeur en sa représentation sous forme de chaîne. La méthode par défaut TimeSpan.ToString() retourne un intervalle de temps à l’aide d’un format invariant identique à sa valeur de retour dans les versions précédentes du .NET Framework. La TimeSpan.ToString(String) surcharge vous permet de spécifier une chaîne de format qui définit la représentation sous forme de chaîne de l’intervalle de temps. La TimeSpan.ToString(String, IFormatProvider) surcharge vous permet de spécifier une chaîne de format et la culture dont les conventions de mise en forme sont utilisées pour créer la représentation sous forme de chaîne de l’intervalle de temps. TimeSpan prend en charge les chaînes de format standard et personnalisées. (Pour plus d’informations, consultez Chaînes de format TimeSpan standard et Chaînes de format TimeSpan personnalisées.) Toutefois, seules les chaînes de format standard respectent la culture.

Restauration de la mise en forme timeSpan héritée

Dans certains cas, le code qui a correctement formaté TimeSpan des valeurs dans .NET Framework 3.5 et les versions antérieures échoue dans .NET Framework 4. C’est le plus courant dans le code qui appelle une méthode d’élément< TimeSpan_LegacyFormatMode> pour mettre en forme une TimeSpan valeur avec une chaîne de format. L’exemple suivant met correctement en forme une TimeSpan valeur dans .NET Framework 3.5 et versions antérieures, mais lève une exception dans .NET Framework 4 et versions ultérieures. Notez qu’il tente de mettre en forme une TimeSpan valeur à l’aide d’un spécificateur de format non pris en charge, qui est ignoré dans .NET Framework 3.5 et versions antérieures.

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

Si vous ne pouvez pas modifier le code, vous pouvez restaurer la mise en forme héritée des TimeSpan valeurs de l’une des manières suivantes :

En créant un fichier de configuration qui contient l’élément< TimeSpan_LegacyFormatMode>. La définition de l’attribut de enabled cet élément sur true restaure la mise en forme héritée TimeSpan par application.

En définissant le commutateur de compatibilité « NetFx40_TimeSpanLegacyFormatMode » lorsque vous créez un domaine d’application. Cela permet la mise en forme héritée TimeSpan par domaine d’application. L’exemple suivant crée un domaine d’application qui utilise la mise en forme héritée 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

Lorsque le code suivant s’exécute dans le nouveau domaine d’application, il rétablit le comportement de mise en forme hérité 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.

Constructeurs

TimeSpan(Int32, Int32, Int32)	Initialise une nouvelle instance de la structure TimeSpan avec un nombre d'heures, de minutes et de secondes spécifié.
TimeSpan(Int32, Int32, Int32, Int32)	Initialise une nouvelle instance de la structure TimeSpan avec un nombre de jours, d'heures, de minutes et de secondes spécifié.
TimeSpan(Int32, Int32, Int32, Int32, Int32)	Initialise une nouvelle instance de la structure TimeSpan avec un nombre de jours, d'heures, de minutes, de secondes et de millisecondes spécifié.
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)	Initialise une nouvelle instance de la TimeSpan structure avec un nombre spécifié de jours, d’heures, de minutes, de secondes, de millisecondes et de microsecondes.
TimeSpan(Int64)	Initialise une nouvelle instance de la structure TimeSpan avec le nombre de graduations spécifié.

Champs

MaxValue	Représente la valeur maximale de TimeSpan. Ce champ est en lecture seule.
MinValue	Représente la valeur minimale de TimeSpan. Ce champ est en lecture seule.
NanosecondsPerTick	Représente le nombre de nanosecondes par graduation. Ce champ est constant.
TicksPerDay	Représente le nombre de graduations en 1 jour. Ce champ est constant.
TicksPerHour	Représente le nombre de graduations en 1 heure. Ce champ est constant.
TicksPerMicrosecond	Représente le nombre de cycles en 1 microseconde. Ce champ est constant.
TicksPerMillisecond	Représente le nombre de graduations en 1 milliseconde. Ce champ est constant.
TicksPerMinute	Représente le nombre de graduations en 1 minute. Ce champ est constant.
TicksPerSecond	Représente le nombre de graduations en 1 seconde.
Zero	Représente la valeur zéro de TimeSpan. Ce champ est en lecture seule.

Propriétés

Days	Obtient le composant « jours » de l'intervalle de temps représenté par la structure TimeSpan actuelle.
Hours	Obtient le composant « heures » de l'intervalle de temps représenté par la structure TimeSpan actuelle.
Microseconds	Obtient le composant de microsecondes de l’intervalle de temps représenté par la structure actuelle TimeSpan .
Milliseconds	Obtient le composant « millisecondes » de l'intervalle de temps représenté par la structure TimeSpan actuelle.
Minutes	Obtient le composant « minutes » de l'intervalle de temps représenté par la structure TimeSpan actuelle.
Nanoseconds	Obtient le composant nanosecondes de l’intervalle de temps représenté par la structure actuelle TimeSpan .
Seconds	Obtient le composant « secondes » de l'intervalle de temps représenté par la structure TimeSpan actuelle.
Ticks	Obtient le nombre de graduations qui représente la valeur de la structure TimeSpan actuelle.
TotalDays	Obtient la valeur de la structure TimeSpan actuelle exprimée en jours entiers et fractionnaires.
TotalHours	Obtient la valeur de la structure TimeSpan actuelle exprimée en heures entières et fractionnaires.
TotalMicroseconds	Obtient la valeur de la structure actuelle TimeSpan exprimée en microsecondes entières et fractionnaires.
TotalMilliseconds	Obtient la valeur de la structure TimeSpan actuelle exprimée en millisecondes entières et fractionnaires.
TotalMinutes	Obtient la valeur de la structure TimeSpan actuelle exprimée en minutes entières et fractionnaires.
TotalNanoseconds	Obtient la valeur de la structure actuelle TimeSpan exprimée en nanosecondes entières et fractionnaires.
TotalSeconds	Obtient la valeur de la structure TimeSpan actuelle exprimée en secondes entières et fractionnaires.

Méthodes

Add(TimeSpan)	Retourne un nouvel objet TimeSpan dont la valeur est la somme de l'objet TimeSpan spécifié et de cette instance.
Compare(TimeSpan, TimeSpan)	Compare deux valeurs TimeSpan et retourne un entier qui indique si la première valeur est plus courte, identique ou plus longue que la deuxième valeur.
CompareTo(Object)	Compare cette instance à un objet spécifié et retourne un entier qui indique si cette instance est plus courte, de même longueur ou plus longue que l'objet spécifié.
CompareTo(TimeSpan)	Compare cette instance à un objet TimeSpan spécifié et retourne un entier qui indique si cette instance est plus courte, identique ou plus longue que l'objet TimeSpan.
Divide(Double)	Retourne un nouvel objet TimeSpan dont la valeur est le résultat de la division de cette instance et du `divisor` spécifié.
Divide(TimeSpan)	Retourne une nouvelle valeur Double qui est le résultat de la division de cette instance et du `ts` spécifié.
Duration()	Retourne un nouvel objet TimeSpan dont la valeur représente la valeur absolue de l'objet TimeSpan actuel.
Equals(Object)	Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.
Equals(TimeSpan)	Retourne une valeur indiquant si cette instance est égale à un objet TimeSpan spécifié.
Equals(TimeSpan, TimeSpan)	Retourne une valeur qui indique si deux instances spécifiées de TimeSpan sont égales.
FromDays(Double)	Retourne un TimeSpan qui représente un nombre de jours spécifié, dont la spécification est précise à la milliseconde près.
FromHours(Double)	Retourne un TimeSpan qui représente un nombre d'heures spécifié, dont la spécification est précise à la milliseconde près.
FromMicroseconds(Double)	Retourne un TimeSpan qui représente un nombre spécifié de microsecondes.
FromMilliseconds(Double)	Retourne un TimeSpan qui représente un nombre spécifié de millisecondes.
FromMinutes(Double)	Retourne un TimeSpan qui représente un nombre de minutes spécifié, dont la spécification est précise à la milliseconde près.
FromSeconds(Double)	Retourne un TimeSpan qui représente un nombre de secondes spécifié, dont la spécification est précise à la milliseconde près.
FromTicks(Int64)	Retourne un TimeSpan qui représente une durée spécifiée, où la spécification est en unités de graduations.
GetHashCode()	Retourne un code de hachage pour cette instance.
Multiply(Double)	Retourne un nouvel objet TimeSpan dont la valeur est le résultat de la multiplication de cette instance et du `factor` spécifié.
Negate()	Retourne un nouvel objet TimeSpan dont la valeur correspond à la valeur inversée de cette instance.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Convertit la représentation sous forme d’étendue d'un intervalle de temps dans son équivalent TimeSpan à l'aide des informations de format spécifiques à la culture spécifiées.
Parse(String)	Convertit la représentation sous forme de chaîne d'un intervalle de temps en TimeSpan équivalent.
Parse(String, IFormatProvider)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide des informations de format spécifiques à la culture spécifiées.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Convertit l’étendue de caractères d'un intervalle de temps dans son équivalent TimeSpan à l'aide des informations de format spécifiques à la culture spécifiées. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide des formats, des informations de format spécifiques à la culture et des styles spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.
ParseExact(String, String, IFormatProvider)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide des informations de format spécifiques à la culture spécifiées. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide des styles et des informations de format spécifiques à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
ParseExact(String, String[], IFormatProvider)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide du tableau de chaînes de format et des informations de format spécifiques à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide des formats, des informations de format spécifiques à la culture et des styles spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.
Subtract(TimeSpan)	Retourne un nouvel objet TimeSpan dont la valeur est la différence entre l'objet TimeSpan spécifié et cette instance.
ToString()	Convertit la valeur de l'objet TimeSpan actif en sa représentation équivalente sous forme de chaîne.
ToString(String)	Convertit la valeur de l'objet TimeSpan actuel dans sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.
ToString(String, IFormatProvider)	Convertit la valeur de l'objet TimeSpan actuel dans sa représentation sous forme de chaîne équivalente à l'aide du format et des informations de mise en forme spécifiques à la culture spécifiés.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance d’intervalle de temps actuelle dans la plage de caractères fournie.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Convertit la représentation sous forme d’étendue spécifiée d'un intervalle de temps dans son équivalent TimeSpan à l'aide des informations de mise en forme spécifiques à la culture et retourne une valeur qui indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, TimeSpan)	Convertit la représentation sous forme d’étendue d'un intervalle de temps dans son équivalent TimeSpan et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, IFormatProvider, TimeSpan)	Convertit la représentation sous forme de chaîne spécifiée d'un intervalle de temps dans son équivalent TimeSpan à l'aide des informations de mise en forme spécifiques à la culture et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, TimeSpan)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan et retourne une valeur qui indique si la conversion a réussi.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Convertit la représentation de plage spécifiée d’un intervalle de temps dans son équivalent TimeSpan en utilisant des informations de format spécifiques à la culture spécifiées. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Convertit la représentation sous forme de chaîne spécifiée d'un intervalle de temps dans son équivalent TimeSpan à l'aide des formats, des informations de format spécifiques à la culture et des styles spécifiés, et retourne une valeur qui indique si la conversion a réussi. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Convertit la représentation de plage spécifiée d’un intervalle de temps dans son équivalent TimeSpan en utilisant des informations de formats spécifiques à la culture spécifiées. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Convertit la représentation de plage spécifiée d’un intervalle de temps dans son équivalent TimeSpan à l'aide des formats, des informations de format spécifiques à la culture et des styles spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide des informations de format spécifiques à la culture spécifiées. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Convertit la représentation de chaîne d’un intervalle de temps dans son équivalent TimeSpan à l’aide des styles et des informations de format spécifiques à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Convertit la représentation de chaîne spécifiée d’un intervalle de temps dans son équivalent TimeSpan en utilisant des informations de formats spécifiques à la culture spécifiées. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Convertit la représentation de chaîne spécifiée d’un intervalle de temps dans son équivalent TimeSpan à l’aide des formats, des informations de format spécifiques à la culture et des styles spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.

Opérateurs

Addition(TimeSpan, TimeSpan)	Ajoute les deux instances spécifiées de TimeSpan.
Division(TimeSpan, Double)	Retourne un nouvel objet TimeSpan dont la valeur est le résultat de la division de l’instance `timeSpan` et du `divisor` spécifié.
Division(TimeSpan, TimeSpan)	Retourne une nouvelle valeur Double qui est le résultat de la division de l’instance `t1` et du `t2` spécifié.
Equality(TimeSpan, TimeSpan)	Indique si deux instances de TimeSpan sont égales.
GreaterThan(TimeSpan, TimeSpan)	Indique si un TimeSpan spécifié est supérieur à un autre TimeSpan spécifié.
GreaterThanOrEqual(TimeSpan, TimeSpan)	Indique si un TimeSpan spécifié est supérieur ou égal à un autre TimeSpan spécifié.
Inequality(TimeSpan, TimeSpan)	Indique si deux instances de TimeSpan ne sont pas égales.
LessThan(TimeSpan, TimeSpan)	Indique si un TimeSpan spécifié est inférieur à un autre TimeSpan spécifié.
LessThanOrEqual(TimeSpan, TimeSpan)	Indique si un TimeSpan spécifié est inférieur ou égal à un autre TimeSpan spécifié.
Multiply(Double, TimeSpan)	Retourne un nouvel objet TimeSpan dont la valeur est le résultat de la multiplication du `factor` spécifié et de l’instance `timeSpan` spécifiée.
Multiply(TimeSpan, Double)	Retourne un nouvel objet TimeSpan dont la valeur est le résultat de la multiplication de l’instance `timeSpan` spécifiée et du `factor` spécifié.
Subtraction(TimeSpan, TimeSpan)	Soustrait un TimeSpan spécifié d'un autre TimeSpan spécifié.
UnaryNegation(TimeSpan)	Retourne un TimeSpan dont la valeur correspond à la valeur inversée de l'instance spécifiée.
UnaryPlus(TimeSpan)	Retourne l'instance spécifiée de TimeSpan.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)

Compare cette instance à un objet spécifié et retourne un entier qui indique si cette instance est plus courte, de même longueur ou plus longue que l'objet spécifié.

S’applique à