TimeSpan Estructura

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

TimeSpan.cs

Representa un intervalo de tiempo.

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

Herencia

Object

ValueType

TimeSpan

Implementaciones

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

Ejemplos

En el ejemplo siguiente se crea una instancia de un TimeSpan objeto que representa la diferencia entre dos fechas. A continuación, muestra las TimeSpan propiedades del 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
#>

Comentarios

Un TimeSpan objeto representa un intervalo de tiempo (duración del tiempo o tiempo transcurrido) que se mide como un número positivo o negativo de días, horas, minutos, segundos y fracciones de un segundo. La TimeSpan estructura también se puede usar para representar la hora del día, pero solo si la hora no está relacionada con una fecha determinada. De lo contrario, se debe usar la estructura DateTime o la DateTimeOffset en su lugar. (Para obtener más información sobre el uso de la TimeSpan estructura para reflejar la hora del día, vea Elegir entre DateTime, DateTimeOffset, TimeSpan y TimeZoneInfo).

Note

Un TimeSpan valor representa un intervalo de tiempo y se puede expresar como un número determinado de días, horas, minutos, segundos y milisegundos. Dado que representa un intervalo general sin referencia a un punto inicial o final determinado, no se puede expresar en términos de años y meses, ambos que tienen un número variable de días. Difiere de un DateTime valor, que representa una fecha y hora sin referencia a una zona horaria determinada, o un DateTimeOffset valor, que representa un momento específico de la hora.

La unidad de tiempo más grande que usa la TimeSpan estructura para medir la duración es un día. Los intervalos de tiempo se miden en días para la coherencia, ya que el número de días en unidades de tiempo mayores, como meses y años, varía.

El valor de un objeto TimeSpan es el número de ticks que equivale al intervalo de tiempo representado. Un tick es igual a 100 nanosegundos, o una diezmillonésima parte de un segundo. El valor de un TimeSpan objeto puede oscilar entre TimeSpan.MinValue y TimeSpan.MaxValue.

Instanciar un valor TimeSpan

Se puede instanciar un valor de TimeSpan de varias maneras.

• Mediante una llamada a su constructor sin parámetros implícito. Esto crea un objeto cuyo valor es TimeSpan.Zero, como se muestra en el ejemplo siguiente.

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

• Llamando a uno de sus compiladores explícitos. En el ejemplo siguiente se inicializa un TimeSpan valor en un número especificado de horas, minutos y 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".
  

• Llamando a un método o realizando una operación que devuelve un TimeSpan valor. Por ejemplo, puede crear instancias de un TimeSpan valor que represente el intervalo entre dos valores de fecha y hora, como se muestra en el ejemplo siguiente.

  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
  

  También puede inicializar un TimeSpan objeto en un valor de tiempo cero de la siguiente manera, como se muestra en el ejemplo siguiente.

  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 Los valores son devueltos por los operadores aritméticos y los métodos de las estructuras DateTime, DateTimeOffset y TimeSpan.

• Analizando la representación de cadena de un valor TimeSpan. Puede usar los Parse métodos y TryParse para convertir cadenas que contienen intervalos de tiempo en TimeSpan valores. En el ejemplo siguiente se usa el Parse método para convertir una matriz de cadenas en TimeSpan valores.

  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'
  

  Además, puede definir el formato preciso de la cadena de entrada que se va a analizar y convertir en un valor TimeSpan llamando al método ParseExact o TryParseExact.

Realizar operaciones en valores TimeSpan

Puede agregar y restar duraciones de tiempo usando los Addition y Subtraction operadores, o llamando a los Add y Subtract métodos. También puede comparar dos duraciones de tiempo llamando a los Comparemétodos , CompareToy Equals . La TimeSpan estructura también incluye los Duration métodos y Negate , que convierten intervalos de tiempo en valores positivos y negativos,

El intervalo de TimeSpan valores es MinValue para MaxValue.

Dar formato a un valor TimeSpan

Un TimeSpan valor se puede representar como [-]d.hh:mm:ss. ff, donde el signo menos opcional indica un intervalo de tiempo negativo, el componente d es días, hh es horas medida en un reloj de 24 horas, mm es minutos, ss es segundos y ff es fracciones de un segundo. Es decir, un intervalo de tiempo consta de un número positivo o negativo de días sin una hora del día, o un número de días con una hora del día o solo una hora del día.

La TimeSpan estructura admite el formato que distingue la referencia cultural a través de las sobrecargas de su ToString método, que convierte un TimeSpan valor en su representación de cadena. La TimeSpan.ToString(String) sobrecarga permite especificar una cadena de formato que define cómo se representa el intervalo de tiempo como cadena. La sobrecarga TimeSpan.ToString(String, IFormatProvider) permite especificar una cadena de formato y la cultura cuyas convenciones de formato se utilizan para crear la representación de cadena del intervalo de tiempo. TimeSpan admite cadenas de formato estándar y personalizado. (Para obtener más información, vea Cadenas de formato TimeSpan estándar y Cadenas de formato TimeSpan personalizadas). Sin embargo, solo las cadenas de formato estándar distinguen la referencia cultural.

Constructores

Nombre	Description
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de días, horas, minutos, segundos, milisegundos y microsegundos especificados.
TimeSpan(Int32, Int32, Int32, Int32, Int32)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de días, horas, minutos, segundos y milisegundos especificados.
TimeSpan(Int32, Int32, Int32, Int32)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de días, horas, minutos y segundos.
TimeSpan(Int32, Int32, Int32)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de horas, minutos y segundos.
TimeSpan(Int64)	Inicializa una nueva instancia de la TimeSpan estructura en el número especificado de tics.

Campos

Nombre	Description
HoursPerDay	Representa el número de horas en 1 día. Este campo es constante.
MaxValue	Representa el valor máximo TimeSpan . Este campo es de sólo lectura.
MicrosecondsPerDay	Representa el número de microsegundos en 1 día. Este campo es constante.
MicrosecondsPerHour	Representa el número de microsegundos en 1 hora. Este campo es constante.
MicrosecondsPerMillisecond	Representa el número de microsegundos en 1 milisegundos. Este campo es constante.
MicrosecondsPerMinute	Representa el número de microsegundos en 1 minuto. Este campo es constante.
MicrosecondsPerSecond	Representa el número de microsegundos en 1 segundo. Este campo es constante.
MillisecondsPerDay	Representa el número de milisegundos en 1 día. Este campo es constante.
MillisecondsPerHour	Representa el número de milisegundos en 1 hora. Este campo es constante.
MillisecondsPerMinute	Representa el número de milisegundos en 1 minuto. Este campo es constante.
MillisecondsPerSecond	Representa el número de milisegundos en 1 segundo. Este campo es constante.
MinutesPerDay	Representa el número de minutos en 1 día. Este campo es constante.
MinutesPerHour	Representa el número de minutos en 1 hora. Este campo es constante.
MinValue	Representa el valor mínimo TimeSpan . Este campo es de sólo lectura.
NanosecondsPerTick	Representa el número de nanosegundos por tic. Este campo es constante.
SecondsPerDay	Representa el número de segundos en 1 día. Este campo es constante.
SecondsPerHour	Representa el número de segundos en 1 hora. Este campo es constante.
SecondsPerMinute	Representa el número de segundos en 1 minuto. Este campo es constante.
TicksPerDay	Representa el número de tics en 1 día. Este campo es constante.
TicksPerHour	Representa el número de tics en 1 hora. Este campo es constante.
TicksPerMicrosecond	Representa el número de tics en 1 microsegundo. Este campo es constante.
TicksPerMillisecond	Representa el número de tics en 1 milisegundos. Este campo es constante.
TicksPerMinute	Representa el número de tics en 1 minuto. Este campo es constante.
TicksPerSecond	Representa el número de tics en 1 segundo.
Zero	Representa el valor cero TimeSpan . Este campo es de sólo lectura.

Propiedades

Nombre	Description
Days	Obtiene el componente days del intervalo de tiempo representado por la estructura actual TimeSpan .
Hours	Obtiene el componente hours del intervalo de tiempo representado por la estructura actual TimeSpan .
Microseconds	Obtiene el componente microsegundos del intervalo de tiempo representado por la estructura actual TimeSpan .
Milliseconds	Obtiene el componente milisegundos del intervalo de tiempo representado por la estructura actual TimeSpan .
Minutes	Obtiene el componente de minutos del intervalo de tiempo representado por la estructura actual TimeSpan .
Nanoseconds	Obtiene el componente nanosegundos del intervalo de tiempo representado por la estructura actual TimeSpan .
Seconds	Obtiene el componente de segundos del intervalo de tiempo representado por la estructura actual TimeSpan .
Ticks	Obtiene el número de tics que representan el valor de la estructura actual TimeSpan .
TotalDays	Obtiene el valor de la estructura actual TimeSpan expresada en días enteros y fraccionarios.
TotalHours	Obtiene el valor de la estructura actual TimeSpan expresada en horas enteras y fraccionarios.
TotalMicroseconds	Obtiene el valor de la estructura actual TimeSpan expresada en microsegundos enteros y fraccionarios.
TotalMilliseconds	Obtiene el valor de la estructura actual TimeSpan expresada en milisegundos enteros y fraccionarios.
TotalMinutes	Obtiene el valor de la estructura actual TimeSpan expresada en minutos enteros y fraccionarios.
TotalNanoseconds	Obtiene el valor de la estructura actual TimeSpan expresada en nanosegundos enteros y fraccionarios.
TotalSeconds	Obtiene el valor de la estructura actual TimeSpan expresada en segundos enteros y fraccionarios.

Métodos

Nombre	Description
Add(TimeSpan)	Devuelve un nuevo TimeSpan objeto cuyo valor es la suma del objeto especificado TimeSpan y esta instancia.
Compare(TimeSpan, TimeSpan)	Compara dos TimeSpan valores y devuelve un entero que indica si el primer valor es menor, igual o mayor que el segundo valor.
CompareTo(Object)	Compara esta instancia con un objeto especificado y devuelve un entero que indica si esta instancia es menor que, igual o mayor que el objeto especificado.
CompareTo(TimeSpan)	Compara esta instancia con un objeto especificado TimeSpan y devuelve un entero que indica si esta instancia es menor que, igual o mayor que el TimeSpan objeto.
Divide(Double)	Devuelve un nuevo TimeSpan objeto cuyo valor es el resultado de dividir esta instancia por el especificado divisor.
Divide(TimeSpan)	Devuelve un nuevo Double valor que es el resultado de dividir esta instancia por ts.
Duration()	Devuelve un nuevo TimeSpan objeto cuyo valor es el valor absoluto del objeto actual TimeSpan .
Equals(Object)	Devuelve un valor que indica si esta instancia es igual a un objeto especificado.
Equals(TimeSpan, TimeSpan)	Devuelve un valor que indica si dos instancias especificadas de TimeSpan son iguales.
Equals(TimeSpan)	Devuelve un valor que indica si esta instancia es igual a un objeto especificado TimeSpan .
FromDays(Double)	Devuelve un TimeSpan que representa un número especificado de días, donde la especificación es precisa para el milisegundo más cercano.
FromDays(Int32, Int32, Int64, Int64, Int64, Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de días, horas, minutos, segundos, milisegundos y microsegundos especificados.
FromDays(Int32)	Inicializa una nueva instancia de la TimeSpan estructura en un número de días especificado.
FromHours(Double)	Devuelve un TimeSpan valor de tipo que representa un número especificado de horas, donde la especificación es precisa para el milisegundo más cercano.
FromHours(Int32, Int64, Int64, Int64, Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de horas, minutos, segundos, milisegundos y microsegundos especificados.
FromHours(Int32)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de horas.
FromMicroseconds(Double)	Devuelve un TimeSpan objeto que representa un número especificado de microsegundos.
FromMicroseconds(Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de microsegundos.
FromMilliseconds(Double)	Devuelve un TimeSpan que representa un número especificado de milisegundos.
FromMilliseconds(Int64, Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de milisegundos y microsegundos.
FromMilliseconds(Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de milisegundos.
FromMinutes(Double)	Devuelve un TimeSpan que representa un número especificado de minutos, donde la especificación es precisa para el milisegundo más cercano.
FromMinutes(Int64, Int64, Int64, Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de minutos, segundos, milisegundos y microsegundos especificados.
FromMinutes(Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número de minutos especificado.
FromSeconds(Double)	Devuelve un TimeSpan que representa un número especificado de segundos, donde la especificación es precisa para el milisegundo más cercano.
FromSeconds(Int64, Int64, Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número especificado de segundos, milisegundos y microsegundos.
FromSeconds(Int64)	Inicializa una nueva instancia de la TimeSpan estructura en un número de segundos especificado.
FromTicks(Int64)	Devuelve un TimeSpan que representa un tiempo especificado, donde la especificación está en unidades de tics.
GetHashCode()	Devuelve un código hash para esta instancia.
Multiply(Double)	Devuelve un nuevo TimeSpan objeto que es el resultado de la multiplicación de esta instancia y el objeto especificado factor.
Negate()	Devuelve un nuevo TimeSpan objeto cuyo valor es el valor negado de esta instancia.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Convierte la representación de intervalo de un intervalo en su TimeSpan equivalente mediante la información de formato específica de la referencia cultural especificada.
Parse(String, IFormatProvider)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante la información de formato específica de la referencia cultural especificada.
Parse(String)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)	Convierte el intervalo char de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, la información de formato específica de la referencia cultural y los estilos. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.
ParseExact(String, String, IFormatProvider, TimeSpanStyles)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado, la información de formato específica de la referencia cultural y los estilos especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
ParseExact(String, String, IFormatProvider)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
ParseExact(String, String[], IFormatProvider, TimeSpanStyles)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, la información de formato específica de la referencia cultural y los estilos. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.
ParseExact(String, String[], IFormatProvider)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante la matriz especificada de cadenas de formato e información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.
Subtract(TimeSpan)	Devuelve un nuevo TimeSpan objeto cuyo valor es la diferencia entre el objeto especificado TimeSpan y esta instancia.
ToString()	Convierte el valor del objeto actual TimeSpan en su representación de cadena equivalente.
ToString(String, IFormatProvider)	Convierte el valor del objeto actual TimeSpan en su representación de cadena equivalente mediante el formato especificado y la información de formato específica de la referencia cultural.
ToString(String)	Convierte el valor del objeto actual TimeSpan en su representación de cadena equivalente mediante el formato especificado.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual del número de intervalo de tiempo en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Convierte la representación de intervalo de un intervalo en su TimeSpan equivalente mediante la información de formato específica de la referencia cultural especificada y devuelve un valor que indica si la conversión se realizó correctamente.
TryParse(ReadOnlySpan<Char>, TimeSpan)	Convierte la representación de intervalo de un intervalo en su TimeSpan equivalente y devuelve un valor que indica si la conversión se realizó correctamente.
TryParse(String, IFormatProvider, TimeSpan)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante la información de formato específica de la referencia cultural especificada y devuelve un valor que indica si la conversión se realizó correctamente.
TryParse(String, TimeSpan)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente y devuelve un valor que indica si la conversión se realizó correctamente.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)	Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)	Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado, la información de formato específico de la referencia cultural y los estilos, y devuelve un valor que indica si la conversión se realizó correctamente. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)	Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, la información y los estilos de formato específicos de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.
TryParseExact(String, String, IFormatProvider, TimeSpan)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)	Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado, la información y los estilos de formato específicos de la referencia cultural especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.
TryParseExact(String, String[], IFormatProvider, TimeSpan)	Convierte la representación de cadena especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.
TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)	Convierte la representación de cadena especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, información y estilos de formato específicos de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

Operadores

Nombre	Description
Addition(TimeSpan, TimeSpan)	Agrega dos instancias especificadas TimeSpan .
Division(TimeSpan, Double)	Devuelve un nuevo TimeSpan objeto cuyo valor es el resultado de dividir el especificado timeSpan por el especificado divisor.
Division(TimeSpan, TimeSpan)	Devuelve un nuevo Double valor que es el resultado de dividir t1 por t2.
Equality(TimeSpan, TimeSpan)	Indica si dos TimeSpan instancias son iguales.
GreaterThan(TimeSpan, TimeSpan)	Indica si un especificado TimeSpan es mayor que otro especificado TimeSpan.
GreaterThanOrEqual(TimeSpan, TimeSpan)	Indica si un especificado TimeSpan es mayor o igual que otro especificado TimeSpan.
Inequality(TimeSpan, TimeSpan)	Indica si dos TimeSpan instancias no son iguales.
LessThan(TimeSpan, TimeSpan)	Indica si un objeto especificado TimeSpan es menor que otro especificado TimeSpan.
LessThanOrEqual(TimeSpan, TimeSpan)	Indica si un especificado TimeSpan es menor o igual que otro especificado TimeSpan.
Multiply(Double, TimeSpan)	Devuelve un nuevo TimeSpan objeto cuyo valor es el resultado de multiplicar el especificado factor y la instancia especificada timeSpan .
Multiply(TimeSpan, Double)	Devuelve un nuevo TimeSpan objeto cuyo valor es el resultado de multiplicar la instancia especificada timeSpan y el objeto especificado factor.
Subtraction(TimeSpan, TimeSpan)	Resta un objeto especificado TimeSpan de otro especificado TimeSpan.
UnaryNegation(TimeSpan)	Devuelve un TimeSpan cuyo valor es el valor negado de la instancia especificada.
UnaryPlus(TimeSpan)	Devuelve la instancia especificada de TimeSpan.

Consulte también

• DateTime
• DateTimeOffset
• Calendar