TimeSpan Structure

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
TimeSpan
Attributs
Implémente

Exemples

L’exemple suivant instancie un objet TimeSpan 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 propriétés de l’objet TimeSpan.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);

// 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 objet TimeSpan 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 structure TimeSpan 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. Dans le cas contraire, la structure DateTime ou DateTimeOffset doit être utilisée à la place.Otherwise, the DateTime or DateTimeOffset structure should be used instead. (Pour plus d’informations sur l’utilisation de la structure TimeSpan 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 valeur de TimeSpan 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 valeur DateTime, qui représente une date et une heure sans référence à un fuseau horaire particulier, ou une valeur DateTimeOffset, 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 la structure TimeSpan 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 objet TimeSpan est le nombre de graduations égal à 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 objet TimeSpan 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 une valeur TimeSpan 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 est TimeSpan.Zero, 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 valeur TimeSpan à 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 retourne une valeur TimeSpan.By calling a method or performing an operation that returns a TimeSpan value. Par exemple, vous pouvez instancier une valeur TimeSpan 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 objet TimeSpan 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.

       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
    
    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 valeurs sont retournées par les opérateurs arithmétiques et les méthodes des structures DateTime, DateTimeOffsetet TimeSpan.TimeSpan values are returned by arithmetic operators and methods of the DateTime, DateTimeOffset, and TimeSpan structures.

  • En analysant la représentation sous forme de chaîne d’une valeur TimeSpan.By parsing the string representation of a TimeSpan value. Vous pouvez utiliser les méthodes Parse et TryParse pour convertir des chaînes qui contiennent des intervalles de temps en TimeSpan valeurs.You can use the Parse and TryParse methods to convert strings that contain time intervals to TimeSpan values. L’exemple suivant utilise la méthode Parse pour convertir un tableau de chaînes en valeurs TimeSpan.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 en TimeSpan valeur en appelant la méthode ParseExact 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 des opérateurs Addition et Subtraction, ou en appelant les méthodes Add et Subtract.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 méthodes Compare, CompareToet Equals.You can also compare two time durations by calling the Compare, CompareTo, and Equals methods. La structure TimeSpan comprend également les méthodes Duration et Negate, qui convertissent des 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 valeurs de TimeSpan est MinValue à MaxValue.The range of TimeSpan values is MinValue to MaxValue.

Mise en forme d’une valeur TimeSpanFormatting a TimeSpan Value

Une valeur de TimeSpan 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 de seconde.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.

À partir de la .NET Framework 4.NET Framework 4, la structure TimeSpan prend en charge la mise en forme dépendante de la culture par le biais des surcharges de sa méthode ToString, qui convertit une valeur TimeSpan 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 surcharge TimeSpan.ToString(String) 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 surcharge de TimeSpan.ToString(String, IFormatProvider) 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. TimeSpan prend 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 correctement en forme les valeurs TimeSpan dans .NET Framework 3.5.NET Framework 3.5 et les versions antérieures échoue dans .NET Framework 4.NET Framework 4.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 valeur TimeSpan 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 une valeur TimeSpan dans .NET Framework 3.5.NET Framework 3.5 et les versions antérieures, mais lève une exception dans .NET Framework 4.NET Framework 4 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 forme une valeur TimeSpan à l’aide d’un spécificateur de format non pris en charge, qui est ignoré dans .NET Framework 3.5.NET Framework 3.5 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.

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);
   }
}
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 valeurs de TimeSpan 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’attribut enabled de cet élément sur true restaure la mise en forme des TimeSpan héritées 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 la mise en forme des TimeSpan héritées 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 la mise en forme de TimeSpan 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 mise en forme hérité TimeSpan.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(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)

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)

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.

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.

Champs

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

Représente la valeur minimale de TimeSpan.Represents the minimum TimeSpan value. Ce champ est en lecture seule.This field is read-only.

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

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

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

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

Représente le nombre de graduations en 1 seconde.Represents the number of ticks in 1 second.

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

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

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

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

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

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

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

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

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

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

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

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.

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.Returns a new TimeSpan object whose value is the sum of the specified TimeSpan object and this 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.Compares two TimeSpan values and returns an integer that indicates whether the first value is shorter than, equal to, or longer than the second value.

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é.Compares this instance to a specified object and returns an integer that indicates whether this instance is shorter than, equal to, or longer than the specified object.

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.Compares this instance to a specified TimeSpan object and returns an integer that indicates whether this instance is shorter than, equal to, or longer than the TimeSpan object.

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é.Returns a new TimeSpan object which value is the result of division of this instance and the specified divisor.

Divide(TimeSpan)

Retourne une nouvelle valeur Double qui est le résultat de la division de cette instance et du ts spécifié.Returns a new Double value which is the result of division of this instance and the specified ts.

Duration()

Retourne un nouvel objet TimeSpan dont la valeur représente la valeur absolue de l'objet TimeSpan actuel.Returns a new TimeSpan object whose value is the absolute value of the current TimeSpan object.

Equals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.Returns a value indicating whether this instance is equal to a specified object.

Equals(TimeSpan)

Retourne une valeur indiquant si cette instance est égale à un objet TimeSpan spécifié.Returns a value indicating whether this instance is equal to a specified TimeSpan object.

Equals(TimeSpan, TimeSpan)

Retourne une valeur qui indique si deux instances spécifiées de TimeSpan sont égales.Returns a value that indicates whether two specified instances of TimeSpan are equal.

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.Returns a TimeSpan that represents a specified number of days, where the specification is accurate to the nearest millisecond.

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.Returns a TimeSpan that represents a specified number of hours, where the specification is accurate to the nearest millisecond.

FromMilliseconds(Double)

Retourne un TimeSpan qui représente un nombre spécifié de millisecondes.Returns a TimeSpan that represents a specified number of milliseconds.

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.Returns a TimeSpan that represents a specified number of minutes, where the specification is accurate to the nearest millisecond.

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.Returns a TimeSpan that represents a specified number of seconds, where the specification is accurate to the nearest millisecond.

FromTicks(Int64)

Retourne un TimeSpan qui représente une durée spécifiée, où la spécification est en unités de graduations.Returns a TimeSpan that represents a specified time, where the specification is in units of ticks.

GetHashCode()

Retourne un code de hachage pour cette instance.Returns a hash code for this 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é.Returns a new TimeSpan object which value is the result of multiplication of this instance and the specified factor.

Negate()

Retourne un nouvel objet TimeSpan dont la valeur correspond à la valeur inversée de cette instance.Returns a new TimeSpan object whose value is the negated value of this 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.Converts the span representation of a time interval to its TimeSpan equivalent by using the specified culture-specific format information.

Parse(String)

Convertit la représentation sous forme de chaîne d'un intervalle de temps en TimeSpan équivalent.Converts the string representation of a time interval to its TimeSpan equivalent.

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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified culture-specific format information.

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.Converts the char span of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified array of format strings and culture-specific format information. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

Subtract(TimeSpan)

Retourne un nouvel objet TimeSpan dont la valeur est la différence entre l'objet TimeSpan spécifié et cette instance.Returns a new TimeSpan object whose value is the difference between the specified TimeSpan object and this instance.

ToString()

Convertit la valeur de l'objet TimeSpan actif en sa représentation équivalente sous forme de chaîne.Converts the value of the current TimeSpan object to its equivalent string representation.

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é.Converts the value of the current TimeSpan object to its equivalent string representation by using the specified format.

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.Converts the value of the current TimeSpan object to its equivalent string representation by using the specified format and culture-specific formatting information.

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.Tries to format the value of the current timespan number instance into the provided span of characters.

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.Converts the span representation of a time interval to its TimeSpan equivalent by using the specified culture-specific formatting information, and returns a value that indicates whether the conversion succeeded.

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.Converts the span representation of a time interval to its TimeSpan equivalent and returns a value that indicates whether the conversion succeeded.

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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified culture-specific formatting information, and returns a value that indicates whether the conversion succeeded.

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.Converts the string representation of a time interval to its TimeSpan equivalent and returns a value that indicates whether the conversion succeeded.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, 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 formats et des informations de format spécifiques à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.Converts the specified span representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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.Converts the specified span representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

TryParseExact(ReadOnlySpan<Char>, String[], 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 formats et des informations de format spécifiques à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.Converts the specified span representation of a time interval to its TimeSpan equivalent by using the specified formats and culture-specific format information, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

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

Convertit la représentation sous forme d’étendue 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.Converts the specified span representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

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 du format et des informations de format spécifiques à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

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

Convertit la représentation sous forme de chaîne d'un intervalle de temps dans son équivalent TimeSpan à l'aide du format, 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.Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.The format of the string representation must match the specified format exactly.

TryParseExact(String, 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 formats et des informations de format spécifiques à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats and culture-specific format information, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

TryParseExact(String, String[], 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.Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. Le format de la représentation sous forme de chaîne doit correspondre exactement à l'un des formats spécifiés.The format of the string representation must match one of the specified formats exactly.

Opérateurs

Addition(TimeSpan, TimeSpan)

Ajoute les deux instances spécifiées de TimeSpan.Adds two specified TimeSpan instances.

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é.Returns a new TimeSpan object which value is the result of division of timeSpan instance and the specified divisor.

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é.Returns a new Double value which is the result of division of t1 instance and the specified t2.

Equality(TimeSpan, TimeSpan)

Indique si deux instances de TimeSpan sont égales.Indicates whether two TimeSpan instances are equal.

GreaterThan(TimeSpan, TimeSpan)

Indique si un TimeSpan spécifié est supérieur à un autre TimeSpan spécifié.Indicates whether a specified TimeSpan is greater than another specified TimeSpan.

GreaterThanOrEqual(TimeSpan, TimeSpan)

Indique si un TimeSpan spécifié est supérieur ou égal à un autre TimeSpan spécifié.Indicates whether a specified TimeSpan is greater than or equal to another specified TimeSpan.

Inequality(TimeSpan, TimeSpan)

Indique si deux instances de TimeSpan ne sont pas égales.Indicates whether two TimeSpan instances are not equal.

LessThan(TimeSpan, TimeSpan)

Indique si un TimeSpan spécifié est inférieur à un autre TimeSpan spécifié.Indicates whether a specified TimeSpan is less than another specified TimeSpan.

LessThanOrEqual(TimeSpan, TimeSpan)

Indique si un TimeSpan spécifié est inférieur ou égal à un autre TimeSpan spécifié.Indicates whether a specified TimeSpan is less than or equal to another specified TimeSpan.

Multiply(Double, TimeSpan)

Retourne un nouvel objet TimeSpan dont la valeur est le résultat de la multiplication de l’instance timeSpan et du factor spécifié.Returns a new TimeSpan object which value is the result of multiplication of timeSpan instance and the specified factor.

Multiply(TimeSpan, Double)
Subtraction(TimeSpan, TimeSpan)

Soustrait un TimeSpan spécifié d'un autre TimeSpan spécifié.Subtracts a specified TimeSpan from another specified TimeSpan.

UnaryNegation(TimeSpan)

Retourne un TimeSpan dont la valeur correspond à la valeur inversée de l'instance spécifiée.Returns a TimeSpan whose value is the negated value of the specified instance.

UnaryPlus(TimeSpan)

Retourne l'instance spécifiée de TimeSpan.Returns the specified instance of TimeSpan.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)

S’applique à

Voir aussi