# TimeSpanTimeSpanTimeSpanTimeSpan Struct

## Définition

Représente un intervalle de temps.Represents a time interval.

``public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable``
``````[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable``````
``````type TimeSpan = struct
interface IFormattable``````
``````Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IFormattable``````
Héritage
TimeSpanTimeSpanTimeSpanTimeSpan
Attributs
Implémente

## Exemples

L’exemple suivant instancie un TimeSpan objet qui représente la différence entre deux dates.The following example instantiates a TimeSpan object that represents the difference between two dates. Il affiche ensuite les TimeSpan propriétés de l’objet.It then displays the TimeSpan object's properties.

``````// 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);
// 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.
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é comme un nombre positif ou négatif de jours, d’heures, de minutes, de secondes et de fractions de seconde.A TimeSpan object represents a time interval (duration of time or elapsed time) that is measured as a positive or negative number of days, hours, minutes, seconds, and fractions of a second. 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.The TimeSpan structure can also be used to represent the time of day, but only if the time is unrelated to a particular date. Sinon, la DateTime structure DateTimeOffset ou doit être utilisée à la place.Otherwise, the DateTime or DateTimeOffset structure should be used instead. (Pour plus d’informations sur l' TimeSpan utilisation de la structure pour refléter l’heure de la journée, consultez choix entre DateTime, DateTimeOffset, TimeSpan et TimeZoneInfo.)(For more information about using the TimeSpan structure to reflect the time of day, see Choosing Between DateTime, DateTimeOffset, TimeSpan, and 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.A TimeSpan value represents a time interval and can be expressed as a particular number of days, hours, minutes, seconds, and milliseconds. Étant donné qu’il s’agit d’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, tous deux ayant un nombre variable de jours.Because it represents a general interval without reference to a particular start or end point, it cannot be expressed in terms of years and months, both of which have a variable number of days. Elle diffère d’une DateTime valeur, qui représente une date et une heure sans référence à un fuseau horaire particulier, ou DateTimeOffset une valeur qui représente un moment précis.It differs from a DateTime value, which represents a date and time without reference to a particular time zone, or a DateTimeOffset value, which represents a specific moment of time.

La plus grande unité de temps que TimeSpan la structure utilise pour mesurer la durée est un jour.The largest unit of time that the TimeSpan structure uses to measure duration is a day. Les intervalles de temps sont mesurés en jours pour des raisons de cohérence, car le nombre de jours dans les unités de temps plus grandes, comme les mois et les années, varie.Time intervals are measured in days for consistency, because the number of days in larger units of time, such as months and years, varies.

La valeur d’un TimeSpan objet est le nombre de graduations qui sont égales à l’intervalle de temps représenté.The value of a TimeSpan object is the number of ticks that equal the represented time interval. Une graduation est égale à 100 nanosecondes, ou à 1 10-millionième de seconde.A tick is equal to 100 nanoseconds, or one ten-millionth of a second. La valeur d’un TimeSpan objet peut être comprise entre TimeSpan.MinValue et TimeSpan.MaxValue.The value of a TimeSpan object can range from TimeSpan.MinValue to TimeSpan.MaxValue.

### Instanciation d’une valeur TimeSpanInstantiating a TimeSpan Value

Vous pouvez instancier TimeSpan une valeur de plusieurs façons:You can instantiate a TimeSpan value in a number of ways:

• En appelant son constructeur sans paramètre implicite.By calling its implicit parameterless constructor. Cela crée un objet dont la valeur TimeSpan.Zeroest, comme le montre l’exemple suivant.This creates an object whose value is TimeSpan.Zero, as the following example shows.

``````TimeSpan interval = new TimeSpan();
Console.WriteLine(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.By calling one of its explicit constructors. L’exemple suivant initialise une TimeSpan valeur à un nombre d’heures, de minutes et de secondes spécifié.The following example initializes a TimeSpan value to a specified number of hours, minutes, and seconds.

``````TimeSpan interval = new TimeSpan(2, 14, 18);
Console.WriteLine(interval.ToString());              // 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 TimeSpan retourne une valeur.By calling a method or performing an operation that returns a TimeSpan value. Par exemple, vous pouvez instancier TimeSpan une valeur qui représente l’intervalle entre deux valeurs de date et d’heure, comme le montre l’exemple suivant.For example, you can instantiate a TimeSpan value that represents the interval between two date and time values, as the following example shows.

``````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
``````
``````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 avec une valeur d’heure nulle de cette manière, comme le montre l’exemple suivant.You can also initialize a TimeSpan object to a zero time value in this way, as the following example shows.

``````using System;

public class Example
{
static Random rnd = new Random();

public static void Main()
{
TimeSpan timeSpent = TimeSpan.Zero;

timeSpent += GetTimeBeforeLunch();
timeSpent += GetTimeAfterLunch();

Console.WriteLine("Total time: {0}", timeSpent);
}

private static TimeSpan GetTimeBeforeLunch()
{
return new TimeSpan(rnd.Next(3, 6), 0, 0);
}

private static TimeSpan GetTimeAfterLunch()
{
return new TimeSpan(rnd.Next(3, 6), 0, 0);
}
}
// 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
``````

TimeSpanles valeurs sont retournées par les opérateurs arithmétiques DateTimeOffsetet les TimeSpan DateTimeméthodes des structures, et.TimeSpan values are returned by arithmetic operators and methods of the DateTime, DateTimeOffset, and TimeSpan structures.

• En analysant la représentation sous forme de TimeSpan chaîne d’une valeur.By parsing the string representation of a TimeSpan value. Vous pouvez utiliser les Parse méthodes TryParse et pour convertir des chaînes qui contiennent des intervalles TimeSpan de temps en valeurs.You can use the Parse and TryParse methods to convert strings that contain time intervals to TimeSpan values. L’exemple suivant utilise la Parse méthode pour convertir un tableau de chaînes en TimeSpan valeurs.The following example uses the Parse method to convert an array of strings to TimeSpan values.

``````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'
``````
``````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 TimeSpan en valeur en appelant la ParseExact méthode ou TryParseExact .In addition, you can define the precise format of the input string to be parsed and converted to a TimeSpan value by calling the ParseExact or TryParseExact method.

### Exécution d’opérations sur les valeurs TimeSpanPerforming Operations on TimeSpan Values

Vous pouvez ajouter et soustraire des durées à l’aide Addition des Subtraction opérateurs et, ou en appelant Add les Subtract méthodes et.You can add and subtract time durations either by using the Addition and Subtraction operators, or by calling the Add and Subtract methods. Vous pouvez également comparer deux durées en appelant les Compareméthodes, CompareToet. EqualsYou can also compare two time durations by calling the Compare, CompareTo, and Equals methods. La TimeSpan structure comprend également les Duration méthodes Negate et, qui convertissent les intervalles de temps en valeurs positives et négatives,The TimeSpan structure also includes the Duration and Negate methods, which convert time intervals to positive and negative values,

La plage de TimeSpan valeurs MinValue MaxValueest.The range of TimeSpan values is MinValue to MaxValue.

### Mise en forme d’une valeur TimeSpanFormatting a TimeSpan Value

Une TimeSpan valeur peut être représentée sous la- forme []d. HH:mm:SS. FF, où le signe moins facultatif indique un intervalle de temps négatif, le composant d correspond à Days, hh correspond aux heures mesurées sur une horloge de 24 heures, mm aux minutes, SS aux secondes et FF aux fractions d’un tache.A TimeSpan value can be represented as [-]d.hh:mm:ss.ff, where the optional minus sign indicates a negative time interval, the d component is days, hh is hours as measured on a 24-hour clock, mm is minutes, ss is seconds, and ff is fractions of a second. 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 uniquement d’une heure de la journée.That is, a time interval consists of a positive or negative number of days without a time of day, or a number of days with a time of day, or only a time of day.

À compter de .NET Framework 4.NET Framework 4, la TimeSpan structure prend en charge la mise en forme dépendante de la culture ToString par le biais des surcharges de sa méthode, qui convertit une TimeSpan valeur en sa représentation sous forme de chaîne.Beginning with the .NET Framework 4.NET Framework 4, the TimeSpan structure supports culture-sensitive formatting through the overloads of its ToString method, which converts a TimeSpan value to its string representation. La méthode TimeSpan.ToString() par défaut 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.The default TimeSpan.ToString() method returns a time interval by using an invariant format that is identical to its return value in previous versions of the .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.The TimeSpan.ToString(String) overload lets you specify a format string that defines the string representation of the time interval. 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.The TimeSpan.ToString(String, IFormatProvider) overload lets you specify a format string and the culture whose formatting conventions are used to create the string representation of the time interval. TimeSpanprend en charge les chaînes de format standard et personnalisées.TimeSpan supports both standard and custom format strings. (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 sont dépendantes de la culture.(For more information, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.) However, only standard format strings are culture-sensitive.

### Restauration de la mise en forme TimeSpan héritéeRestoring Legacy TimeSpan Formatting

Dans certains cas, le code qui met TimeSpan correctement en .NET Framework 3.5.NET Framework 3.5 forme les valeurs dans et .NET Framework 4.NET Framework 4les versions antérieures échoue dans.In some cases, code that successfully formats TimeSpan values in .NET Framework 3.5.NET Framework 3.5 and earlier versions fails in .NET Framework 4.NET Framework 4. Cela 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.This is most common in code that calls a <TimeSpan_LegacyFormatMode> element method to format a TimeSpan value with a format string. L’exemple suivant met en forme TimeSpan une valeur .NET Framework 3.5.NET Framework 3.5 dans et les versions antérieures, mais lève une exception .NET Framework 4.NET Framework 4 dans et versions ultérieures.The following example successfully formats a TimeSpan value in .NET Framework 3.5.NET Framework 3.5 and earlier versions, but throws an exception in .NET Framework 4.NET Framework 4 and later versions. Notez qu’il tente de mettre en TimeSpan forme une valeur à l’aide d’un spécificateur de format non pris en charge .NET Framework 3.5.NET Framework 3.5 , qui est ignoré dans et les versions antérieures.Note that it attempts to format a TimeSpan value by using an unsupported format specifier, which is ignored in .NET Framework 3.5.NET Framework 3.5 and earlier versions.

``````TimeSpan interval = new TimeSpan(12, 30, 45);
string output;
try {
output = String.Format("{0:r}", interval);
}
catch (FormatException) {
output = "Invalid Format";
}
Console.WriteLine(output);
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format
``````
``````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 TimeSpan forme héritée des valeurs de l’une des manières suivantes:If you cannot modify the code, you can restore the legacy formatting of TimeSpan values in one of the following ways:

• En créant un fichier de configuration qui contient l' élément < TimeSpan_LegacyFormatMode >.By creating a configuration file that contains the <TimeSpan_LegacyFormatMode> element. La définition de l' `enabled` attribut de `true` cet élément pour rétablir TimeSpan la mise en forme héritée pour chaque application.Setting this element's `enabled` attribute to `true` restores legacy TimeSpan formatting on a per-application basis.

• En définissant le commutateur de compatibilité «NetFx40_TimeSpanLegacyFormatMode» lorsque vous créez un domaine d’application.By setting the "NetFx40_TimeSpanLegacyFormatMode" compatibility switch when you create an application domain. Cela permet une TimeSpan mise en forme héritée pour chaque domaine d’application.This enables legacy TimeSpan formatting on a per-application-domain basis. L’exemple suivant crée un domaine d’application qui utilise TimeSpan la mise en forme héritée.The following example creates an application domain that uses legacy TimeSpan formatting.

``````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");
}
}
``````
``````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 revient au comportement de TimeSpan mise en forme hérité.When the following code executes in the new application domain, it reverts to legacy TimeSpan formatting behavior.

``````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.
``````
``````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(Int64) TimeSpan(Int64) TimeSpan(Int64) TimeSpan(Int64) Initialise une nouvelle instance de la structure TimeSpan avec le nombre de graduations spécifié.Initializes a new instance of the TimeSpan structure to the specified number of ticks. TimeSpan(Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32) Initialise une nouvelle instance de la structure TimeSpan avec un nombre d'heures, de minutes et de secondes spécifié.Initializes a new instance of the TimeSpan structure to a specified number of hours, minutes, and seconds. TimeSpan(Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32) 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é.Initializes a new instance of the TimeSpan structure to a specified number of days, hours, minutes, and seconds. TimeSpan(Int32, Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32, Int32) 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é.Initializes a new instance of the TimeSpan structure to a specified number of days, hours, minutes, seconds, and milliseconds.

## Champs

 MaxValue MaxValue MaxValue MaxValue Représente la valeur maximale de TimeSpan.Represents the maximum TimeSpan value. Ce champ est en lecture seule.This field is read-only. MinValue MinValue MinValue MinValue Représente la valeur minimale de TimeSpan.Represents the minimum TimeSpan value. Ce champ est en lecture seule.This field is read-only. TicksPerDay TicksPerDay TicksPerDay TicksPerDay Représente le nombre de graduations en 1 jour.Represents the number of ticks in 1 day. Ce champ est constant.This field is constant. TicksPerHour TicksPerHour TicksPerHour TicksPerHour Représente le nombre de graduations en 1 heure.Represents the number of ticks in 1 hour. Ce champ est constant.This field is constant. TicksPerMillisecond TicksPerMillisecond TicksPerMillisecond TicksPerMillisecond Représente le nombre de graduations en 1 milliseconde.Represents the number of ticks in 1 millisecond. Ce champ est constant.This field is constant. TicksPerMinute TicksPerMinute TicksPerMinute TicksPerMinute Représente le nombre de graduations en 1 minute.Represents the number of ticks in 1 minute. Ce champ est constant.This field is constant. TicksPerSecond TicksPerSecond TicksPerSecond TicksPerSecond Représente le nombre de graduations en 1 seconde.Represents the number of ticks in 1 second. Zero Zero Zero Zero Représente la valeur zéro de TimeSpan.Represents the zero TimeSpan value. Ce champ est en lecture seule.This field is read-only.

## Propriétés

 Days Days Days Days Obtient le composant « jours » de l'intervalle de temps représenté par la structure TimeSpan actuelle.Gets the days component of the time interval represented by the current TimeSpan structure. Hours Hours Hours Hours Obtient le composant « heures » de l'intervalle de temps représenté par la structure TimeSpan actuelle.Gets the hours component of the time interval represented by the current TimeSpan structure. Milliseconds Milliseconds Milliseconds Milliseconds Obtient le composant « millisecondes » de l'intervalle de temps représenté par la structure TimeSpan actuelle.Gets the milliseconds component of the time interval represented by the current TimeSpan structure. Minutes Minutes Minutes Minutes Obtient le composant « minutes » de l'intervalle de temps représenté par la structure TimeSpan actuelle.Gets the minutes component of the time interval represented by the current TimeSpan structure. Seconds Seconds Seconds Seconds Obtient le composant « secondes » de l'intervalle de temps représenté par la structure TimeSpan actuelle.Gets the seconds component of the time interval represented by the current TimeSpan structure. Ticks Ticks Ticks Ticks Obtient le nombre de graduations qui représente la valeur de la structure TimeSpan actuelle.Gets the number of ticks that represent the value of the current TimeSpan structure. TotalDays TotalDays TotalDays TotalDays Obtient la valeur de la structure TimeSpan actuelle exprimée en jours entiers et fractionnaires.Gets the value of the current TimeSpan structure expressed in whole and fractional days. TotalHours TotalHours TotalHours TotalHours Obtient la valeur de la structure TimeSpan actuelle exprimée en heures entières et fractionnaires.Gets the value of the current TimeSpan structure expressed in whole and fractional hours. TotalMilliseconds TotalMilliseconds TotalMilliseconds TotalMilliseconds Obtient la valeur de la structure TimeSpan actuelle exprimée en millisecondes entières et fractionnaires.Gets the value of the current TimeSpan structure expressed in whole and fractional milliseconds. TotalMinutes TotalMinutes TotalMinutes TotalMinutes Obtient la valeur de la structure TimeSpan actuelle exprimée en minutes entières et fractionnaires.Gets the value of the current TimeSpan structure expressed in whole and fractional minutes. TotalSeconds TotalSeconds TotalSeconds TotalSeconds Obtient la valeur de la structure TimeSpan actuelle exprimée en secondes entières et fractionnaires.Gets the value of the current TimeSpan structure expressed in whole and fractional seconds.