TimeSpan Structure

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, 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 IParsable<TimeSpan> IParsable<TSelf> ISpanFormattable ISpanParsable<TimeSpan> IUtf8SpanFormattable

Exemples

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

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

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

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

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

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

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

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

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

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

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

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

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

<# This sample produces the following output:

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

Remarques

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

Note

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

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

La valeur d’un objet TimeSpan correspond au nombre de cycles qui correspondent à l’intervalle de temps représenté. Un tick est égal à 100 nanosecondes, ou un dix-millionième de seconde. La valeur d’un TimeSpan objet peut être comprise entre TimeSpan.MinValueTimeSpan.MaxValue.

Instancier une valeur TimeSpan

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

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

  TimeSpan interval = new TimeSpan();
  Console.WriteLine(interval.Equals(TimeSpan.Zero));    // Displays "True".
  

  let interval = TimeSpan()
  printfn $"{interval.Equals TimeSpan.Zero}"    // Displays "True".
  

  Dim interval As New TimeSpan()
  Console.WriteLine(interval.Equals(TimeSpan.Zero))     ' Displays "True".
  

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

  TimeSpan interval = new TimeSpan(2, 14, 18);
  Console.WriteLine(interval.ToString());              
  
  // Displays "02:14:18".
  

  let interval = TimeSpan(2, 14, 18)
  printfn $"{interval}"              
  
  // Displays "02:14:18".
  

  Dim interval As New TimeSpan(2, 14, 18)
  Console.WriteLine(interval.ToString())                ' Displays "02:14:18".
  

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

  DateTime departure = new DateTime(2010, 6, 12, 18, 32, 0);
  DateTime arrival = new DateTime(2010, 6, 13, 22, 47, 0);
  TimeSpan travelTime = arrival - departure;  
  Console.WriteLine($"{arrival} - {departure} = {travelTime}");      
  
  // The example displays the following output:
  //       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
  

  let departure = DateTime(2010, 6, 12, 18, 32, 0)
  let arrival = DateTime(2010, 6, 13, 22, 47, 0)
  let travelTime = arrival - departure  
  printfn $"{arrival} - {departure} = {travelTime}"
  
  // The example displays the following output:
  //       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
  

  Dim departure As DateTime = #06/12/2010 6:32PM#
  Dim arrival As DateTime = #06/13/2010 10:47PM#
  Dim travelTime As TimeSpan = arrival - departure
  Console.WriteLine("{0} - {1} = {2}", arrival, departure, travelTime)
  ' The example displays the following output:
  '       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
  

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

  Random rnd = new Random();
  
  TimeSpan timeSpent = TimeSpan.Zero;
  
  timeSpent += GetTimeBeforeLunch();
  timeSpent += GetTimeAfterLunch();
  
  Console.WriteLine($"Total time: {timeSpent}");
  
  TimeSpan GetTimeBeforeLunch()
  {
      return new TimeSpan(rnd.Next(3, 6), 0, 0);
  }
  
  TimeSpan GetTimeAfterLunch()
  {
      return new TimeSpan(rnd.Next(3, 6), 0, 0);
  }
  
  // The example displays output like the following:
  //        Total time: 08:00:00
  

  open System
  
  let rnd = Random()
  
  let getTimeBeforeLunch () =
      TimeSpan(rnd.Next(3, 6), 0, 0)
  
  let getTimeAfterLunch() =
      TimeSpan(rnd.Next(3, 6), 0, 0)
  
  do
      let timeSpent = TimeSpan.Zero
  
      let timeSpent = timeSpent + getTimeBeforeLunch ()
      let timeSpent = timeSpent + getTimeAfterLunch ()
  
      printfn $"Total time: {timeSpent}"
  
  
  // The example displays output like the following:
  //        Total time: 08:00:00
  

  Module MExample
      Dim rnd As New Random()
  
      Public Sub Main()
          Dim timeSpent As TimeSpan = TimeSpan.Zero
  
          timeSpent += GetTimeBeforeLunch()
          timeSpent += GetTimeAfterLunch()
  
          Console.WriteLine("Total time: {0}", timeSpent)
      End Sub
  
      Private Function GetTimeBeforeLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
      End Function
  
      Private Function GetTimeAfterLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
      End Function
  End Module
  ' The example displays output like the following:
  '       Total time: 08:00:00
  

  TimeSpan Les valeurs sont retournées par des opérateurs arithmétiques et les méthodes des structures DateTime, DateTimeOffset, et TimeSpan.

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

  string[] values = { "12", "31.", "5.8:32:16", "12:12:15.95", ".12"};
  foreach (string value in values)
  {
     try {
        TimeSpan ts = TimeSpan.Parse(value);
        Console.WriteLine($"'{value}' --> {ts}");
     }
     catch (FormatException) {
        Console.WriteLine($"Unable to parse '{value}'");
     }
     catch (OverflowException) {
        Console.WriteLine($"'{value}' is outside the range of a TimeSpan.");
     }   
  }
  
  // The example displays the following output:
  //       '12' --> 12.00:00:00
  //       Unable to parse '31.'
  //       '5.8:32:16' --> 5.08:32:16
  //       '12:12:15.95' --> 12:12:15.9500000
  //       Unable to parse '.12'
  

  let values = [| "12"; "31."; "5.8:32:16"; "12:12:15.95"; ".12" |]
  for value in values do
      try
          let ts = TimeSpan.Parse value
          printfn $"'{value}' --> {ts}"
      with 
      | :? FormatException ->
          printfn $"Unable to parse '{value}'"
      | :? OverflowException ->
          printfn $"'{value}' is outside the range of a TimeSpan."
  
  // The example displays the following output:
  //       '12' --> 12.00:00:00
  //       Unable to parse '31.'
  //       '5.8:32:16' --> 5.08:32:16
  //       '12:12:15.95' --> 12:12:15.9500000
  //       Unable to parse '.12'
  

  Dim values() As String = {"12", "31.", "5.8:32:16", "12:12:15.95", ".12"}
  For Each value As String In values
      Try
          Dim ts As TimeSpan = TimeSpan.Parse(value)
          Console.WriteLine("'{0}' --> {1}", value, ts)
      Catch e As FormatException
          Console.WriteLine("Unable to parse '{0}'", value)
      Catch e As OverflowException
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value)
      End Try
  Next
  ' The example displays the following output:
  '       '12' --> 12.00:00:00
  '       Unable to parse '31.'
  '       '5.8:32:16' --> 5.08:32:16
  '       '12:12:15.95' --> 12:12:15.9500000
  '       Unable to parse '.12'
  

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

Effectuer des opérations sur les valeurs TimeSpan

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

La plage de TimeSpan valeurs est MinValue à MaxValue.

Mettre en forme une valeur TimeSpan

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 est le nombre de jours, hh est le nombre d'heures mesurées sur une horloge de 24 heures, mm est le nombre de minutes, ss est le nombre de secondes, et ff est une fraction de seconde. Autrement dit, un intervalle de temps se compose d’un nombre positif ou négatif de jours sans heure de jour, ou d’un certain nombre de jours avec une heure de jour, ou seulement une heure de jour.

La TimeSpan structure prend en charge la mise en forme sensible à la culture par le biais des surcharges de sa ToString méthode, qui convertit une TimeSpan valeur en sa représentation sous forme de chaîne. La TimeSpan.ToString(String) surcharge vous permet de spécifier une chaîne de format qui définit la représentation sous forme de chaîne de l’intervalle de temps. La TimeSpan.ToString(String, IFormatProvider) surcharge vous permet de spécifier une chaîne de format et la culture dont les conventions de mise en forme sont utilisées pour créer la représentation sous forme de chaîne de l’intervalle de temps. TimeSpan prend en charge les chaînes de format standard et personnalisées. (Pour plus d’informations, consultez Chaînes de format timeSpan standard et chaînes de format TimeSpan personnalisées.) Toutefois, seules les chaînes de format standard respectent la culture.

Constructeurs

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

Champs

Nom	Description
HoursPerDay	Représente le nombre d’heures en 1 jour. Ce champ est constant.
MaxValue	Représente la valeur maximale TimeSpan . Ce champ est en lecture seule.
MicrosecondsPerDay	Représente le nombre de microsecondes en 1 jour. Ce champ est constant.
MicrosecondsPerHour	Représente le nombre de microsecondes en 1 heure. Ce champ est constant.
MicrosecondsPerMillisecond	Représente le nombre de microsecondes en 1 milliseconde. Ce champ est constant.
MicrosecondsPerMinute	Représente le nombre de microsecondes en 1 minute. Ce champ est constant.
MicrosecondsPerSecond	Représente le nombre de microsecondes en 1 seconde. Ce champ est constant.
MillisecondsPerDay	Représente le nombre de millisecondes en 1 jour. Ce champ est constant.
MillisecondsPerHour	Représente le nombre de millisecondes en 1 heure. Ce champ est constant.
MillisecondsPerMinute	Représente le nombre de millisecondes en 1 minute. Ce champ est constant.
MillisecondsPerSecond	Représente le nombre de millisecondes en 1 seconde. Ce champ est constant.
MinutesPerDay	Représente le nombre de minutes en 1 jour. Ce champ est constant.
MinutesPerHour	Représente le nombre de minutes en 1 heure. Ce champ est constant.
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.
SecondsPerDay	Représente le nombre de secondes en 1 jour. Ce champ est constant.
SecondsPerHour	Représente le nombre de secondes en 1 heure. Ce champ est constant.
SecondsPerMinute	Représente le nombre de secondes en 1 minute. 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 zéro TimeSpan . Ce champ est en lecture seule.

Propriétés

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

Méthodes

Nom	Description
Add(TimeSpan)	Retourne un nouvel TimeSpan objet dont la valeur est la somme de l’objet spécifié TimeSpan et de cette instance.
Compare(TimeSpan, TimeSpan)	Compare deux TimeSpan valeurs 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 spécifié TimeSpan 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 TimeSpan objet dont la valeur est le résultat de la division de cette instance par le paramètre spécifié divisor.
Divide(TimeSpan)	Retourne une nouvelle Double valeur qui est le résultat de la division de cette instance par ts.
Duration()	Retourne un nouvel TimeSpan objet dont la valeur est la valeur absolue de l’objet actuel TimeSpan .
Equals(Object)	Retourne une valeur indiquant si cette instance est égale à un objet spécifié.
Equals(TimeSpan, TimeSpan)	Retourne une valeur qui indique si deux instances TimeSpan spécifiées sont égales.
Equals(TimeSpan)	Retourne une valeur indiquant si cette instance est égale à un objet spécifié TimeSpan .
FromDays(Double)	Retourne une TimeSpan valeur qui représente un nombre spécifié de jours, où la spécification est exacte à la milliseconde la plus proche.
FromDays(Int32, Int32, Int64, Int64, Int64, Int64)	Initialise une nouvelle instance de la TimeSpan structure à un nombre spécifié de jours, d’heures, de minutes, de secondes, de millisecondes et de microsecondes.
FromDays(Int32)	Initialise une nouvelle instance de la TimeSpan structure à un nombre spécifié de jours.
FromHours(Double)	Retourne une TimeSpan valeur qui représente un nombre d’heures spécifié, où la spécification est exacte à la milliseconde la plus proche.
FromHours(Int32, Int64, Int64, Int64, Int64)	Initialise une nouvelle instance de la TimeSpan structure à un nombre spécifié d’heures, de minutes, de secondes, de millisecondes et de microsecondes.
FromHours(Int32)	Initialise une nouvelle instance de la TimeSpan structure à un nombre d’heures spécifié.
FromMicroseconds(Double)	Retourne une TimeSpan valeur qui représente un nombre spécifié de microsecondes.
FromMicroseconds(Int64)	Initialise une nouvelle instance de la TimeSpan structure à un nombre spécifié de microsecondes.
FromMilliseconds(Double)	Retourne une TimeSpan valeur qui représente un nombre spécifié de millisecondes.
FromMilliseconds(Int64, Int64)	Initialise une nouvelle instance de la TimeSpan structure en un nombre spécifié de millisecondes et de microsecondes.
FromMilliseconds(Int64)	Initialise une nouvelle instance de la TimeSpan structure à un nombre spécifié de millisecondes.
FromMinutes(Double)	Retourne une TimeSpan valeur qui représente un nombre spécifié de minutes, où la spécification est exacte à la milliseconde la plus proche.
FromMinutes(Int64, Int64, Int64, Int64)	Initialise une nouvelle instance de la TimeSpan structure à un nombre spécifié de minutes, de secondes, de millisecondes et de microsecondes.
FromMinutes(Int64)	Initialise une nouvelle instance de la TimeSpan structure à un nombre spécifié de minutes.
FromSeconds(Double)	Retourne une TimeSpan valeur qui représente un nombre spécifié de secondes, où la spécification est exacte à la milliseconde la plus proche.
FromSeconds(Int64, Int64, Int64)	Initialise une nouvelle instance de la TimeSpan structure en un nombre spécifié de secondes, millisecondes et microsecondes.
FromSeconds(Int64)	Initialise une nouvelle instance de la TimeSpan structure en un nombre spécifié de secondes.
FromTicks(Int64)	Retourne une TimeSpan valeur 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 TimeSpan objet dont la valeur est le résultat de la multiplication de cette instance et de l’objet spécifié factor.
Negate()	Retourne un nouvel TimeSpan objet 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 TimeSpan équivalent à l’aide des informations de format spécifiques à la culture spécifiées.
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.
Parse(String)	Convertit la représentation sous forme de chaîne d’un intervalle de temps en son TimeSpan équivalent.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Convertit l’intervalle de caractères 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 spécifiques à 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, TimeSpanStyles)	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 des styles spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
ParseExact(String, String, IFormatProvider)	Convertit la représentation sous forme de chaîne d’un intervalle de temps 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 des formats spécifiés, des informations de format spécifiques à 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 du tableau spécifié de chaînes de format 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.
Subtract(TimeSpan)	Retourne un nouvel TimeSpan objet dont la valeur est la différence entre l’objet spécifié TimeSpan et cette instance.
ToString()	Convertit la valeur de l’objet actuel TimeSpan en sa représentation sous forme de chaîne équivalente.
ToString(String, IFormatProvider)	Convertit la valeur de l’objet actuel TimeSpan 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.
ToString(String)	Convertit la valeur de l’objet actuel TimeSpan en sa représentation sous forme de chaîne équivalente à l’aide du format spécifié.
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 TimeSpan équivalent à l’aide des 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 d’étendue d’un intervalle de temps en son TimeSpan équivalent 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 TimeSpan équivalent à l’aide des 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 TimeSpan équivalent 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 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(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 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 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(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Convertit la représentation sous forme de chaîne spécifiée d’un intervalle de temps en son TimeSpan équivalent à l’aide des formats spécifiés, des informations et des styles 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

Nom	Description
Addition(TimeSpan, TimeSpan)	Ajoute deux instances spécifiées TimeSpan .
Division(TimeSpan, Double)	Retourne un nouvel TimeSpan objet dont la valeur est le résultat de la division timeSpan spécifiée par le paramètre spécifié divisor.
Division(TimeSpan, TimeSpan)	Retourne une nouvelle Double valeur qui est le résultat de la division t1 par t2.
Equality(TimeSpan, TimeSpan)	Indique si deux TimeSpan instances sont égales.
GreaterThan(TimeSpan, TimeSpan)	Indique si un spécifié TimeSpan est supérieur à un autre spécifié TimeSpan.
GreaterThanOrEqual(TimeSpan, TimeSpan)	Indique si un spécifié TimeSpan est supérieur ou égal à un autre spécifié TimeSpan.
Inequality(TimeSpan, TimeSpan)	Indique si deux TimeSpan instances ne sont pas égales.
LessThan(TimeSpan, TimeSpan)	Indique si un spécifié TimeSpan est inférieur à un autre spécifié TimeSpan.
LessThanOrEqual(TimeSpan, TimeSpan)	Indique si un spécifié TimeSpan est inférieur ou égal à un autre spécifié TimeSpan.
Multiply(Double, TimeSpan)	Retourne un nouvel TimeSpan objet dont la valeur est le résultat de la multiplication de l’instance spécifiée factor et de l’instance spécifiée timeSpan .
Multiply(TimeSpan, Double)	Retourne un nouvel TimeSpan objet dont la valeur est le résultat de la multiplication de l’instance spécifiée timeSpan et de l’objet spécifié factor.
Subtraction(TimeSpan, TimeSpan)	Soustrait un spécifié TimeSpan d’un autre spécifié TimeSpan.
UnaryNegation(TimeSpan)	Retourne une TimeSpan valeur 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