TimeSpan Estrutura

Definição

Espaço de Nomes:

System

Assemblagens:

netstandard.dll, System.Runtime.dll

Origem:

TimeSpan.cs

Representa um intervalo de tempo.

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

Herança

Object

ValueType

TimeSpan

Implementações

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

Exemplos

O exemplo seguinte instancia um TimeSpan objeto que representa a diferença entre duas datas. De seguida, apresenta as TimeSpan propriedades do objeto.

// 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
#>

Observações

Um objeto TimeSpan representa um intervalo de tempo (duração do tempo ou tempo decorrido) que é medido como um número positivo ou negativo de dias, horas, minutos, segundos e frações de segundo. A estrutura TimeSpan também pode ser usada para representar a hora do dia, mas apenas se a hora não estiver relacionada a uma data específica. Caso contrário, a estrutura DateTime ou DateTimeOffset deve ser usada. (Para obter mais informações sobre como usar a estrutura TimeSpan para refletir a hora do dia, consulte Escolhendo entre DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.)

Note

Um valor TimeSpan representa um intervalo de tempo e pode ser expresso como um determinado número de dias, horas, minutos, segundos e milissegundos. Por representar um intervalo geral sem referência a um determinado ponto inicial ou final, não pode ser expresso em termos de anos e meses, ambos com um número variável de dias. Ele difere de um valor DateTime, que representa uma data e hora sem referência a um fuso horário específico, ou um valor DateTimeOffset, que representa um momento específico de tempo.

A maior unidade de tempo que a estrutura TimeSpan usa para medir a duração é um dia. Os intervalos de tempo são medidos em dias para consistência, porque o número de dias em unidades maiores de tempo, como meses e anos, varia.

O valor de um objeto TimeSpan é o número de ticks que correspondem ao intervalo de tempo representado. Um tic é igual a 100 nanossegundos, ou um décimo milionésimo de segundo. O valor de um objeto TimeSpan pode variar de TimeSpan.MinValue a TimeSpan.MaxValue.

Instanciar um valor de TimeSpan

Você pode instanciar um valor de TimeSpan de várias maneiras:

• Chamando seu construtor implícito sem parâmetros. Isso cria um objeto cujo valor é TimeSpan.Zero, como mostra o exemplo a seguir.

  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".
  

• Chamando um de seus construtores explícitos. O exemplo a seguir inicializa um valor TimeSpan para um número especificado de horas, minutos e segundos.

  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".
  

• Chamando um método ou executando uma operação que retorna um valor TimeSpan. Por exemplo, você pode instanciar um valor TimeSpan que representa o intervalo entre dois valores de data e hora, como mostra o exemplo a seguir.

  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
  

  Você também pode inicializar um objeto TimeSpan para um valor de tempo zero dessa maneira, como mostra o exemplo a seguir.

  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 valores são retornados por operadores aritméticos e métodos das estruturas DateTime, DateTimeOffsete TimeSpan.

• Ao analisar a representação em formato de cadeia de caracteres de um valor TimeSpan. Você pode usar os métodos Parse e TryParse para converter cadeias de caracteres que contêm intervalos de tempo em valores TimeSpan. O exemplo a seguir usa o método Parse para converter uma matriz de cadeias de caracteres em valores TimeSpan.

  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'
  

  Além disso, você pode definir o formato preciso da cadeia de caracteres de entrada a ser analisada e convertida em um valor TimeSpan chamando o método ParseExact ou TryParseExact.

Executar operações em valores TimeSpan

Você pode adicionar e subtrair durações de tempo usando os operadores Addition e Subtraction ou chamando os métodos Add e Subtract. Você também pode comparar duas durações de tempo chamando os métodos Compare, CompareToe Equals. A estrutura TimeSpan também inclui os métodos Duration e Negate, que convertem intervalos de tempo em valores positivos e negativos,

O intervalo de valores de TimeSpan é MinValue a MaxValue.

Formatar um valor TimeSpan

Um valor TimeSpan pode ser representado como [-]d.hh:mm:ss.ff, onde o sinal de menos opcional indica um intervalo de tempo negativo, o componente d é dias, hh é horas medidas em um relógio de 24 horas, mm é minutos, ss é segundos e ff é frações de segundo. Ou seja, um intervalo de tempo consiste em um número positivo ou negativo de dias sem uma hora do dia, ou um número de dias com uma hora do dia, ou apenas uma hora do dia.

A TimeSpan estrutura suporta formatação sensível à cultura através das sobrecargas do seu ToString método, que converte um TimeSpan valor para a sua representação de strings. A sobrecarga TimeSpan.ToString(String) permite especificar uma string de formato que define a representação do intervalo de tempo em forma de cadeia de caracteres. A sobrecarga TimeSpan.ToString(String, IFormatProvider) permite especificar uma cadeia de caracteres de formato e a cultura cujas convenções de formatação são usadas para criar a representação de cadeia de caracteres do intervalo de tempo. TimeSpan suporta cadeias de caracteres de formato padrão e personalizado. (Para obter mais informações, consulte Strings de formato TimeSpan padrão e Strings de formato TimeSpan personalizadas.) No entanto, apenas strings de formato padrão são sensíveis à cultura.

Construtores

Name	Descrição
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de dias, horas, minutos, segundos, milissegundos e microssegundos.
TimeSpan(Int32, Int32, Int32, Int32, Int32)	Inicializa uma nova instância da TimeSpan estrutura com um número especificado de dias, horas, minutos, segundos e milissegundos.
TimeSpan(Int32, Int32, Int32, Int32)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de dias, horas, minutos e segundos.
TimeSpan(Int32, Int32, Int32)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de horas, minutos e segundos.
TimeSpan(Int64)	Inicializa uma nova instância da TimeSpan estrutura ao número especificado de ticks.

Campos

Name	Descrição
HoursPerDay	Representa o número de horas num dia. Este campo é constante.
MaxValue	Representa o valor máximo TimeSpan . Este campo é só de leitura.
MicrosecondsPerDay	Representa o número de microssegundos em 1 dia. Este campo é constante.
MicrosecondsPerHour	Representa o número de microssegundos em 1 hora. Este campo é constante.
MicrosecondsPerMillisecond	Representa o número de microssegundos em 1 milissegundo. Este campo é constante.
MicrosecondsPerMinute	Representa o número de microssegundos em 1 minuto. Este campo é constante.
MicrosecondsPerSecond	Representa o número de microssegundos em 1 segundo. Este campo é constante.
MillisecondsPerDay	Representa o número de milissegundos em 1 dia. Este campo é constante.
MillisecondsPerHour	Representa o número de milissegundos em 1 hora. Este campo é constante.
MillisecondsPerMinute	Representa o número de milissegundos em 1 minuto. Este campo é constante.
MillisecondsPerSecond	Representa o número de milissegundos em 1 segundo. Este campo é constante.
MinutesPerDay	Representa o número de minutos em 1 dia. Este campo é constante.
MinutesPerHour	Representa o número de minutos em 1 hora. Este campo é constante.
MinValue	Representa o valor mínimo TimeSpan . Este campo é só de leitura.
NanosecondsPerTick	Representa o número de nanossegundos por tick. Este campo é constante.
SecondsPerDay	Representa o número de segundos num dia. Este campo é constante.
SecondsPerHour	Representa o número de segundos em 1 hora. Este campo é constante.
SecondsPerMinute	Representa o número de segundos em 1 minuto. Este campo é constante.
TicksPerDay	Representa o número de tiques em 1 dia. Este campo é constante.
TicksPerHour	Representa o número de tiques em 1 hora. Este campo é constante.
TicksPerMicrosecond	Representa o número de tiques em 1 microssegundo. Este campo é constante.
TicksPerMillisecond	Representa o número de tiques em 1 milissegundo. Este campo é constante.
TicksPerMinute	Representa o número de ticks em 1 minuto. Este campo é constante.
TicksPerSecond	Representa o número de tiques em 1 segundo.
Zero	Representa o valor zero TimeSpan . Este campo é só de leitura.

Propriedades

Name	Descrição
Days	Obtém o componente de dias do intervalo de tempo representado pela estrutura atual TimeSpan .
Hours	Obtém o componente de horas do intervalo de tempo representado pela estrutura atual TimeSpan .
Microseconds	Obtém o componente de microssegundos do intervalo de tempo representado pela estrutura atual TimeSpan .
Milliseconds	Obtém o componente milissegundos do intervalo de tempo representado pela estrutura atual TimeSpan .
Minutes	Obtém o componente de minutos do intervalo de tempo representado pela estrutura atual TimeSpan .
Nanoseconds	Obtém o componente de nanossegundos do intervalo de tempo representado pela estrutura atual TimeSpan .
Seconds	Obtém o componente dos segundos do intervalo de tempo representado pela estrutura atual TimeSpan .
Ticks	Obtém o número de ticks que representam o valor da estrutura atual TimeSpan .
TotalDays	Obtém o valor da estrutura atual TimeSpan expresso em dias inteiros e fracionários.
TotalHours	Obtém o valor da estrutura atual TimeSpan expresso em horas inteiras e fracionárias.
TotalMicroseconds	Obtém o valor da estrutura atual TimeSpan expresso em microssegundos inteiros e fracionários.
TotalMilliseconds	Obtém o valor da estrutura atual TimeSpan expresso em milissegundos totais e fracionários.
TotalMinutes	Obtém o valor da estrutura atual TimeSpan expresso em minutos inteiros e fracionários.
TotalNanoseconds	Obtém o valor da estrutura atual TimeSpan expresso em nanossegundos totais e fracionários.
TotalSeconds	Obtém o valor da estrutura atual TimeSpan expresso em segundos inteiros e fracionais.

Métodos

Name	Descrição
Add(TimeSpan)	Devolve um novo TimeSpan objeto cujo valor é a soma do objeto especificado TimeSpan e desta instância.
Compare(TimeSpan, TimeSpan)	Compara dois TimeSpan valores e devolve um inteiro que indica se o primeiro valor é mais curto, igual ou mais longo que o segundo valor.
CompareTo(Object)	Compara esta instância com um objeto especificado e devolve um inteiro que indica se esta instância é mais curta, igual ou mais longa do que o objeto especificado.
CompareTo(TimeSpan)	Compara esta instância com um objeto especificado TimeSpan e devolve um inteiro que indica se esta instância é mais curta, igual ou mais longa que o TimeSpan objeto.
Divide(Double)	Devolve um novo TimeSpan objeto cujo valor é o resultado de dividir esta instância pelo especificado divisor.
Divide(TimeSpan)	Devolve um novo Double valor que resulta da divisão desta instância por ts.
Duration()	Devolve um novo TimeSpan objeto cujo valor é o valor absoluto do objeto atual TimeSpan .
Equals(Object)	Devolve um valor que indica se esta instância é igual a um objeto especificado.
Equals(TimeSpan, TimeSpan)	Devolve um valor que indica se duas instâncias especificadas de TimeSpan são iguais.
Equals(TimeSpan)	Devolve um valor que indica se esta instância é igual a um objeto especificado TimeSpan .
FromDays(Double)	Devolve a TimeSpan que representa um número especificado de dias, onde a especificação é precisa até ao milissegundo mais próximo.
FromDays(Int32, Int32, Int64, Int64, Int64, Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de dias, horas, minutos, segundos, milissegundos e microssegundos.
FromDays(Int32)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de dias.
FromHours(Double)	Devolve a TimeSpan que representa um número especificado de horas, onde a especificação é precisa até ao milissegundo mais próximo.
FromHours(Int32, Int64, Int64, Int64, Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de horas, minutos, segundos, milissegundos e microssegundos.
FromHours(Int32)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de horas.
FromMicroseconds(Double)	Devolve a TimeSpan que representa um número especificado de microssegundos.
FromMicroseconds(Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de microssegundos.
FromMilliseconds(Double)	Devolve a TimeSpan que representa um número especificado de milissegundos.
FromMilliseconds(Int64, Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de milissegundos e microssegundos.
FromMilliseconds(Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de milissegundos.
FromMinutes(Double)	Devolve a TimeSpan que representa um número especificado de minutos, onde a especificação é precisa até ao milissegundo mais próximo.
FromMinutes(Int64, Int64, Int64, Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de minutos, segundos, milissegundos e microssegundos.
FromMinutes(Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de minutos.
FromSeconds(Double)	Devolve a TimeSpan que representa um número especificado de segundos, onde a especificação é precisa até ao milissegundo mais próximo.
FromSeconds(Int64, Int64, Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de segundos, milissegundos e microssegundos.
FromSeconds(Int64)	Inicializa uma nova instância da TimeSpan estrutura para um número especificado de segundos.
FromTicks(Int64)	Devolve a TimeSpan que representa um tempo especificado, onde a especificação está em unidades de ticks.
GetHashCode()	Devolve um código de hash para esta instância.
Multiply(Double)	Devolve um novo TimeSpan objeto cujo valor é o resultado da multiplicação desta instância e do especificado factor.
Negate()	Devolve um novo TimeSpan objeto cujo valor é o valor negado desta instância.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Converte a representação do intervalo de tempo para o seu TimeSpan equivalente usando a informação de formato específica para cultura.
Parse(String, IFormatProvider)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando a informação de formato específica para cultura.
Parse(String)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Converte o intervalo de caracteres de um intervalo de tempo para o seu TimeSpan equivalente, utilizando o formato especificado e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Converte a representação das strings de um intervalo de tempo para o seu TimeSpan equivalente usando os formatos especificados, informação de formato específica da cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado, informação de formato específica da cultura e estilos. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
ParseExact(String, String, IFormatProvider)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado e a informação específica de formato da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Converte a representação das strings de um intervalo de tempo para o seu TimeSpan equivalente usando os formatos especificados, informação de formato específica da cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
ParseExact(String, String[], IFormatProvider)	Converte a representação das cadeias de um intervalo de tempo para o seu TimeSpan equivalente usando o array especificado de cadeias de formato e informação de formato específica para a cultura. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
Subtract(TimeSpan)	Devolve um novo TimeSpan objeto cujo valor é a diferença entre o objeto especificado TimeSpan e esta instância.
ToString()	Converte o valor do objeto atual TimeSpan para a sua representação equivalente em cadeias.
ToString(String, IFormatProvider)	Converte o valor do objeto atual TimeSpan para a sua representação equivalente de cadeias usando o formato especificado e a informação de formatação específica da cultura.
ToString(String)	Converte o valor do objeto atual TimeSpan para a sua representação equivalente em cadeia usando o formato especificado.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual como UTF-8 no intervalo fornecido de bytes.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância numérica atual no intervalo de caracteres fornecido.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Converte a representação de intervalo de tempo para o seu TimeSpan equivalente usando a informação de formatação específica da cultura e retorna um valor que indica se a conversão teve sucesso.
TryParse(ReadOnlySpan<Char>, TimeSpan)	Converte a representação do span de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão foi bem-sucedida.
TryParse(String, IFormatProvider, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando a informação de formatação específica da cultura especificada, e devolve um valor que indica se a conversão foi bem-sucedida.
TryParse(String, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente e devolve um valor que indica se a conversão foi bem-sucedida.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Converte a representação de expansão especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando o formato especificado e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação do intervalo de tempo especificada para o seu TimeSpan equivalente usando o formato especificado, informação de formato específica da cultura e estilos, e retorna um valor que indica se a conversão foi bem-sucedida. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Converte a representação de espaço especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação do intervalo de tempo especificada para o seu TimeSpan equivalente, utilizando os formatos especificados, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado e a informação específica de formato da cultura. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação da cadeia de um intervalo de tempo para o seu TimeSpan equivalente usando o formato especificado, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Converte a representação de cadeias especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados e a informação de formato específica da cultura. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Converte a representação de strings especificada de um intervalo de tempo para o seu TimeSpan equivalente, utilizando os formatos especificados, informação de formato específica para cultura e estilos. O formato da representação da cadeia deve corresponder exatamente a um dos formatos especificados.

Operadores

Name	Descrição
Addition(TimeSpan, TimeSpan)	Adiciona duas instâncias especificadas TimeSpan .
Division(TimeSpan, Double)	Devolve um novo TimeSpan objeto cujo valor resulta da divisão do especificado timeSpan pelo especificado divisor.
Division(TimeSpan, TimeSpan)	Devolve um novo Double valor que resulta da divisão t1 por t2.
Equality(TimeSpan, TimeSpan)	Indica se duas TimeSpan instâncias são iguais.
GreaterThan(TimeSpan, TimeSpan)	Indica se um especificado TimeSpan é maior do que outro especificado TimeSpan.
GreaterThanOrEqual(TimeSpan, TimeSpan)	Indica se um especificado TimeSpan é maior ou igual a outro especificado TimeSpan.
Inequality(TimeSpan, TimeSpan)	Indica se duas TimeSpan instâncias não são iguais.
LessThan(TimeSpan, TimeSpan)	Indica se um especificado TimeSpan é menor do que outro especificado TimeSpan.
LessThanOrEqual(TimeSpan, TimeSpan)	Indica se um especificado TimeSpan é menor ou igual a outro especificado TimeSpan.
Multiply(Double, TimeSpan)	Devolve um novo TimeSpan objeto cujo valor resulta da multiplicação da instância especificada factor e da especificada timeSpan .
Multiply(TimeSpan, Double)	Devolve um novo TimeSpan objeto cujo valor é o resultado da multiplicação da instância especificada timeSpan pela especificada factor.
Subtraction(TimeSpan, TimeSpan)	Subtrai um especificado TimeSpan de outro especificado TimeSpan.
UnaryNegation(TimeSpan)	Devolve um TimeSpan cujo valor é o valor negado da instância especificada.
UnaryPlus(TimeSpan)	Devolve a instância especificada de TimeSpan.

Ver também

• DateTime
• DateTimeOffset
• Calendar