TimeSpan TimeSpan TimeSpan TimeSpan 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
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);

// 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é 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.

Méthodes

Add(TimeSpan) Add(TimeSpan) Add(TimeSpan) 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(TimeSpan, TimeSpan) Compare(TimeSpan, TimeSpan) 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) CompareTo(Object) CompareTo(Object) 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) CompareTo(TimeSpan) CompareTo(TimeSpan) 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(TimeSpan) Divide(TimeSpan) Divide(TimeSpan) Divide(TimeSpan)
Divide(Double) Divide(Double) Divide(Double) Divide(Double)
Duration() Duration() Duration() 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) Equals(Object) Equals(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) Equals(TimeSpan) Equals(TimeSpan) 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) Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan) 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) FromDays(Double) FromDays(Double) 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) FromHours(Double) FromHours(Double) 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) FromMilliseconds(Double) FromMilliseconds(Double) 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) FromMinutes(Double) FromMinutes(Double) 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) FromSeconds(Double) FromSeconds(Double) 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) FromTicks(Int64) FromTicks(Int64) 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() GetHashCode() GetHashCode() GetHashCode()

Retourne un code de hachage pour cette instance.Returns a hash code for this instance.

Multiply(Double) Multiply(Double) Multiply(Double) Multiply(Double)
Negate() Negate() Negate() 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(String) Parse(String) Parse(String) 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(ReadOnlySpan<Char>, IFormatProvider) Parse(ReadOnlySpan<Char>, IFormatProvider) Parse(ReadOnlySpan<Char>, IFormatProvider) Parse(ReadOnlySpan<Char>, IFormatProvider)
Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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(String, String, IFormatProvider, TimeSpanStyles) ParseExact(String, String, IFormatProvider, TimeSpanStyles) ParseExact(String, String, IFormatProvider, TimeSpanStyles) 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(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)
ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 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.

ParseExact(String, String[], IFormatProvider) ParseExact(String, String[], IFormatProvider) ParseExact(String, String[], IFormatProvider) 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) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) 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(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)
Subtract(TimeSpan) Subtract(TimeSpan) Subtract(TimeSpan) 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(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) 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.

ToString(String) ToString(String) ToString(String) 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() ToString() ToString() 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.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan)
TryParse(String, TimeSpan) TryParse(String, TimeSpan) TryParse(String, TimeSpan) 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.

TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan) 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.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 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(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)
TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan) 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) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) 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.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) 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.

Opérateurs

Addition(TimeSpan, TimeSpan) Addition(TimeSpan, TimeSpan) Addition(TimeSpan, TimeSpan) Addition(TimeSpan, TimeSpan)

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

Division(TimeSpan, TimeSpan) Division(TimeSpan, TimeSpan) Division(TimeSpan, TimeSpan) Division(TimeSpan, TimeSpan)
Division(TimeSpan, Double) Division(TimeSpan, Double) Division(TimeSpan, Double) Division(TimeSpan, Double)
Equality(TimeSpan, TimeSpan) Equality(TimeSpan, TimeSpan) Equality(TimeSpan, TimeSpan) Equality(TimeSpan, TimeSpan)

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

GreaterThan(TimeSpan, TimeSpan) GreaterThan(TimeSpan, TimeSpan) GreaterThan(TimeSpan, TimeSpan) 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) GreaterThanOrEqual(TimeSpan, TimeSpan) GreaterThanOrEqual(TimeSpan, 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) Inequality(TimeSpan, TimeSpan) Inequality(TimeSpan, 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) LessThan(TimeSpan, TimeSpan) LessThan(TimeSpan, TimeSpan) 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) LessThanOrEqual(TimeSpan, TimeSpan) LessThanOrEqual(TimeSpan, 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) Multiply(Double, TimeSpan) Multiply(Double, TimeSpan) Multiply(Double, TimeSpan)
Multiply(TimeSpan, Double) Multiply(TimeSpan, Double) Multiply(TimeSpan, Double) Multiply(TimeSpan, Double)
Subtraction(TimeSpan, TimeSpan) Subtraction(TimeSpan, TimeSpan) Subtraction(TimeSpan, TimeSpan) Subtraction(TimeSpan, TimeSpan)

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

UnaryNegation(TimeSpan) UnaryNegation(TimeSpan) UnaryNegation(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) UnaryPlus(TimeSpan) UnaryPlus(TimeSpan) UnaryPlus(TimeSpan)

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

Implémentations d’interfaces explicites

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)

S’applique à

Voir aussi