TimeSpan Estrutura

Definição

Espaço de Nomes:
System
Assemblagens:
mscorlib.dll, System.Runtime.dll
Assemblagens:
netstandard.dll, System.Runtime.dll
Assemblagem:
System.Runtime.dll
Assemblagem:
mscorlib.dll
Assemblagem:
netstandard.dll
Origem:
TimeSpan.cs
Origem:
TimeSpan.cs
Origem:
TimeSpan.cs
Origem:
TimeSpan.cs
Origem:
TimeSpan.cs

Representa um intervalo de tempo.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
public value class TimeSpan : IComparable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
[System.Serializable]
public struct TimeSpan : IComparable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
type TimeSpan = struct
    interface IFormattable
type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
    interface IUtf8SpanFormattable
type TimeSpan = struct
    interface ISpanFormattable
    interface IFormattable
type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
[<System.Serializable>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
    interface IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan), IUtf8SpanFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), ISpanFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan)
Public Structure TimeSpan
Implements IComparable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan)
Herança
Object
ValueType
TimeSpan
Atributos
SerializableAttribute ComVisibleAttribute
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

Para mais informações sobre esta API, consulte Observações suplementares sobre a API para TimeSpan.

Construtores

Name Description
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 Description
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 Description
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 Description
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 Description
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.

Implementações de Interface Explícita

Name Description
IComparable.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.

Aplica-se a

Ver também