TimeSpan Structure

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Source:

TimeSpan.cs

Représente un intervalle de temps.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
    interface IUtf8SpanFormattable

Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan), IUtf8SpanFormattable

Héritage

Object

ValueType

TimeSpan

Implémente

IComparable IComparable<TimeSpan> IEquatable<TimeSpan> IFormattable ISpanFormattable IParsable<TimeSpan> IParsable<TSelf> ISpanParsable<TimeSpan> IUtf8SpanFormattable

Exemples

L’exemple suivant instancie un objet TimeSpan qui représente la différence entre deux dates. Il affiche ensuite les propriétés de l’objet TimeSpan.

// Define two dates.
DateTime date1 = new DateTime(2010, 1, 1, 8, 0, 15);
DateTime date2 = new DateTime(2010, 8, 18, 13, 30, 30);

// Calculate the interval between the two dates.
TimeSpan interval = date2 - date1;
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString());

// Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays);
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours);
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks);

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000

// Define two dates.
let date1 = DateTime(2010, 1, 1, 8, 0, 15)
let date2 = DateTime(2010, 8, 18, 13, 30, 30)

// Calculate the interval between the two dates.
let interval = date2 - date1
printfn $"{date2} - {date1} = {interval}"

// Display individual properties of the resulting TimeSpan object.
printfn $"""   {"Value of Days Component:",-35} {interval.Days,20}""" 
printfn $"""   {"Total Number of Days:",-35} {interval.TotalDays,20}""" 
printfn $"""   {"Value of Hours Component:",-35} {interval.Hours,20}""" 
printfn $"""   {"Total Number of Hours:",-35} {interval.TotalHours,20}""" 
printfn $"""   {"Value of Minutes Component:",-35} {interval.Minutes,20}""" 
printfn $"""   {"Total Number of Minutes:",-35} {interval.TotalMinutes,20}""" 
printfn $"""   {"Value of Seconds Component:",-35} {interval.Seconds,20:N0}""" 
printfn $"""   {"Total Number of Seconds:",-35} {interval.TotalSeconds,20:N0}""" 
printfn $"""   {"Value of Milliseconds Component:",-35} {interval.Milliseconds,20:N0}""" 
printfn $"""   {"Total Number of Milliseconds:",-35} {interval.TotalMilliseconds,20:N0}""" 
printfn $"""   {"Ticks:",-35} {interval.Ticks,20:N0}""" 

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000

' Define two dates.
Dim date1 As Date = #1/1/2010 8:00:15AM#
Dim date2 As Date = #8/18/2010 1:30:30PM#
' Calculate the interval between the two dates.
Dim interval As TimeSpan = date2 - date1
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString())
' Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays)
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours)
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks)
' The example displays the following output:
'       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
'          Value of Days Component:                             229
'          Total Number of Days:                   229.229340277778
'          Value of Hours Component:                              5
'          Total Number of Hours:                  5501.50416666667
'          Value of Minutes Component:                           30
'          Total Number of Minutes:                       330090.25
'          Value of Seconds Component:                           15
'          Total Number of Seconds:                      19,805,415
'          Value of Milliseconds Component:                       0
'          Total Number of Milliseconds:             19,805,415,000
'          Ticks:                               198,054,150,000,000

# Define two dates.
$Date2 = Get-Date -Date '2010/8/18' -Hour 13 -Minute 30 -Second 30
$Date1 = Get-Date -Date '2010/1/1'  -Hour 8  -Minute 0  -Second 15

# Calculate the interval between the two dates.
$Interval = $Date2 - $Date1
"{0} - {1} = {2}" -f $Date2, $Date1, ($Interval.ToString())

#  Display individual properties of the resulting TimeSpan object.
"   {0,-35} {1,20}"    -f "Value of Days Component:", $Interval.Days
"   {0,-35} {1,20}"    -f "Total Number of Days:", $Interval.TotalDays
"   {0,-35} {1,20}"    -f "Value of Hours Component:", $Interval.Hours
"   {0,-35} {1,20}"    -f "Total Number of Hours:", $Interval.TotalHours
"   {0,-35} {1,20}"    -f "Value of Minutes Component:", $Interval.Minutes
"   {0,-35} {1,20}"    -f "Total Number of Minutes:", $Interval.TotalMinutes
"   {0,-35} {1,20:N0}" -f "Value of Seconds Component:", $Interval.Seconds
"   {0,-35} {1,20:N0}" -f "Total Number of Seconds:", $Interval.TotalSeconds
"   {0,-35} {1,20:N0}" -f "Value of Milliseconds Component:", $Interval.Milliseconds
"   {0,-35} {1,20:N0}" -f "Total Number of Milliseconds:", $Interval.TotalMilliseconds
"   {0,-35} {1,20:N0}" -f "Ticks:", $Interval.Ticks

<# This sample produces the following output:

18/08/2010 13:30:30 - 01/01/2010 08:00:15 = 229.05:30:15
   Value of Days Component:                             229
   Total Number of Days:                   229.229340277778
   Value of Hours Component:                              5
   Total Number of Hours:                  5501.50416666667
   Value of Minutes Component:                           30
   Total Number of Minutes:                       330090.25
   Value of Seconds Component:                           15
   Total Number of Seconds:                      19,805,415
   Value of Milliseconds Component:                       0
   Total Number of Milliseconds:             19,805,415,000
   Ticks:                               198,054,150,000,000
#>

Remarques

Pour plus d’informations sur cette API, consultez remarques de l’API supplémentaire pour timeSpan.

Constructeurs

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

Champs

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

Propriétés

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

Méthodes

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

Opérateurs

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

Voir aussi

• DateTime
• DateTimeOffset
• Calendar