TimeSpan Estructura

Definición

Representa un intervalo de tiempo.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
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>, 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 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), 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)
Herencia
TimeSpan
Atributos
Implementaciones

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 de tiempo o tiempo transcurrido) que se mide como un número positivo o negativo de días, horas, minutos, segundos y fracciones de 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 DateTime estructura o 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).

Nota

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 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 TimeSpan objeto es el número de tics que equivalen al intervalo de tiempo representado. Un tic es igual a 100 nanosegundos, o un diez millones de segundos. El valor de un TimeSpan objeto puede oscilar entre TimeSpan.MinValue y TimeSpan.MaxValue.

Creación de instancias de un valor TimeSpan

Puede crear una instancia de un TimeSpan valor de varias maneras:

  • Mediante una llamada a su constructor implícito sin parámetros. 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 constructores 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 una instancia 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("{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
    
    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 hora cero de esta manera, como se muestra en el ejemplo siguiente.

       Random rnd = new Random();
    
       TimeSpan timeSpent = TimeSpan.Zero;
    
       timeSpent += GetTimeBeforeLunch();
       timeSpent += GetTimeAfterLunch();
    
       Console.WriteLine("Total time: {0}", 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 Example
       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 operadores y métodos aritméticos devuelven los valores de las DateTimeestructuras , DateTimeOffsety TimeSpan .

  • Al analizar la representación de cadena de un TimeSpan valor. 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("'{0}' --> {1}", value, ts);
       }
       catch (FormatException) {
          Console.WriteLine("Unable to parse '{0}'", value);
       }
       catch (OverflowException) {
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value);
       }   
    }
    
    // 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 TimeSpan valor llamando al ParseExact método o TryParseExact .

Realizar operaciones en valores TimeSpan

Puede agregar y restar duraciones de tiempo mediante los Addition operadores y Subtraction , o llamando a los Add métodos y Subtract . 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.

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

A partir de .NET Framework 4, 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. El método predeterminado TimeSpan.ToString() devuelve un intervalo de tiempo mediante un formato invariable que es idéntico a su valor devuelto en versiones anteriores de .NET Framework. La TimeSpan.ToString(String) sobrecarga permite especificar una cadena de formato que define la representación de cadena del intervalo de tiempo. La TimeSpan.ToString(String, IFormatProvider) sobrecarga permite especificar una cadena de formato y la referencia cultural cuyas convenciones de formato se usan 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.

Restauración del formato timeSpan heredado

En algunos casos, el código que da formato TimeSpan correctamente a los valores en .NET Framework 3.5 y versiones anteriores produce un error en .NET Framework 4. Esto es más común en el código que llama a un método de elemento<TimeSpan_LegacyFormatMode> para dar formato a un TimeSpan valor con una cadena de formato. En el ejemplo siguiente se da formato correctamente a un TimeSpan valor en .NET Framework 3.5 y versiones anteriores, pero se produce una excepción en .NET Framework 4 y versiones posteriores. Tenga en cuenta que intenta dar formato a un TimeSpan valor mediante un especificador de formato no admitido, que se omite en .NET Framework 3.5 y versiones anteriores.

ShowFormattingCode();
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format    

Console.WriteLine("---");

ShowParsingCode();
// Output:
//       000000006 --> 6.00:00:00

void ShowFormattingCode()
{
   TimeSpan interval = new TimeSpan(12, 30, 45);
   string output;
   try {
      output = String.Format("{0:r}", interval);
   }
   catch (FormatException) {
      output = "Invalid Format";
   }
   Console.WriteLine(output);
}

void ShowParsingCode()
{
   string value = "000000006";
   try {
      TimeSpan interval = TimeSpan.Parse(value);
      Console.WriteLine("{0} --> {1}", value, interval);
   }
   catch (FormatException) {
      Console.WriteLine("{0}: Bad Format", value);
   }   
   catch (OverflowException) {
      Console.WriteLine("{0}: Overflow", value);
   }
}
let showFormattingCode () =
    let interval = TimeSpan(12, 30, 45)
    try
        $"{interval:r}"
    with :? FormatException ->
        "Invalid Format"
    |> printfn "%s"

let showParsingCode () =
    let value = "000000006"
    try
        let interval = TimeSpan.Parse value
        printfn $"{value} --> {interval}"
    with
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"

showFormattingCode ()
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format    

printfn "---"

showParsingCode ()
// Output:
//       000000006 --> 6.00:00:00
Dim interval As New TimeSpan(12, 30, 45)
Dim output As String
Try
   output = String.Format("{0:r}", interval)
Catch e As FormatException
   output = "Invalid Format"
End Try
Console.WriteLine(output)
' Output from .NET Framework 3.5 and earlier versions:
'       12:30:45
' Output from .NET Framework 4:
'       Invalid Format

Si no puede modificar el código, puede restaurar el formato heredado de TimeSpan los valores de una de las maneras siguientes:

  • Mediante la creación de un archivo de configuración que contiene el elemento<TimeSpan_LegacyFormatMode>. Establecer el atributo de enabled este elemento para true restaurar el formato heredado TimeSpan por aplicación.

  • Al establecer el modificador de compatibilidad "NetFx40_TimeSpanLegacyFormatMode" al crear un dominio de aplicación. Esto permite el formato heredado TimeSpan por dominio de aplicación. En el ejemplo siguiente se crea un dominio de aplicación que usa el formato heredado TimeSpan .

    using System;
    
    public class Example
    {
       public static void Main()
       {
          AppDomainSetup appSetup = new AppDomainSetup();
          appSetup.SetCompatibilitySwitches( new string[] { "NetFx40_TimeSpanLegacyFormatMode" } );
          AppDomain legacyDomain = AppDomain.CreateDomain("legacyDomain", 
                                                          null, appSetup);
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe");
       }
    }
    
    open System
    
    let appSetup = AppDomainSetup()
    appSetup.SetCompatibilitySwitches [| "NetFx40_TimeSpanLegacyFormatMode" |]
    let legacyDomain = AppDomain.CreateDomain("legacyDomain", null, appSetup)
    legacyDomain.ExecuteAssembly "ShowTimeSpan.exe" |> ignore
    
    Module Example
       Public Sub Main()
          Dim appSetup As New AppDomainSetup()
          appSetup.SetCompatibilitySwitches( { "NetFx40_TimeSpanLegacyFormatMode" } )
          Dim legacyDomain As AppDomain = AppDomain.CreateDomain("legacyDomain", 
                                                                 Nothing, appSetup)
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe")
       End Sub
    End Module
    

    Cuando el código siguiente se ejecuta en el nuevo dominio de aplicación, se revierte al comportamiento de formato heredado TimeSpan .

    using System;
    
    public class Example
    {
       public static void Main()
       {
          TimeSpan interval = DateTime.Now - DateTime.Now.Date;
          string msg = String.Format("Elapsed Time Today: {0:d} hours.",
                                     interval);
          Console.WriteLine(msg);
       }
    }
    // The example displays the following output:
    //       Elapsed Time Today: 01:40:52.2524662 hours.
    
    open System
    
    let interval = DateTime.Now - DateTime.Now.Date
    printfn $"Elapsed Time Today: {interval:d} hours."
    // The example displays the following output:
    //       Elapsed Time Today: 01:40:52.2524662 hours.
    
    Module Example
       Public Sub Main()
          Dim interval As TimeSpan = Date.Now - Date.Now.Date
          Dim msg As String = String.Format("Elapsed Time Today: {0:d} hours.",
                                             interval)
          Console.WriteLine(msg)
       End Sub
    End Module
    ' The example displays output like the following:
    '       Elapsed Time Today: 01:40:52.2524662 hours.
    

Constructores

TimeSpan(Int32, Int32, Int32)

Inicializa una nueva instancia de la estructura TimeSpan con un número de horas, minutos y segundos especificado.

TimeSpan(Int32, Int32, Int32, Int32)

Inicializa una nueva instancia de la estructura TimeSpan con un número de días, horas, minutos y segundos especificado.

TimeSpan(Int32, Int32, Int32, Int32, Int32)

Inicializa una nueva instancia de la estructura TimeSpan con un número de días, horas, minutos, segundos y milisegundos especificado.

TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)

Inicializa una nueva instancia de la estructura TimeSpan con un número de días, horas, minutos, segundos y milisegundos especificado.

TimeSpan(Int64)

Inicializa una nueva instancia de la estructura TimeSpan en un número de pasos especificado.

Campos

MaxValue

Representa el valor máximo de TimeSpan. Este campo es de solo lectura.

MinValue

Representa el valor mínimo de TimeSpan. Este campo es de solo lectura.

NanosecondsPerTick

Representa el número de nanosegundos por tic. Este campo es constante.

TicksPerDay

Representa el número de pasos en 1 día. Este campo es constante.

TicksPerHour

Representa el número de pasos en 1 hora. Este campo es constante.

TicksPerMicrosecond

Representa el número de tics en 1 microsegundos. Este campo es constante.

TicksPerMillisecond

Representa el número de pasos en 1 milisegundo. Este campo es constante.

TicksPerMinute

Representa el número de pasos en 1 minuto. Este campo es constante.

TicksPerSecond

Representa el número de pasos en 1 segundo.

Zero

Representa el valor cero de TimeSpan. Este campo es de solo lectura.

Propiedades

Days

Obtiene el componente de días del intervalo de tiempo representado por la estructura TimeSpan actual.

Hours

Obtiene el componente de días del intervalo de tiempo representado por la estructura TimeSpan actual.

Microseconds

Obtiene el componente microsegundos del intervalo de tiempo representado por la estructura actual TimeSpan .

Milliseconds

Obtiene el componente de milisegundos del intervalo de tiempo representado por la estructura TimeSpan actual.

Minutes

Obtiene el componente de minutos del intervalo de tiempo representado por la estructura TimeSpan actual.

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 TimeSpan actual.

Ticks

Obtiene el número de pasos que representa el valor de la estructura TimeSpan actual.

TotalDays

Obtiene el valor de la estructura TimeSpan actual, expresado en días completos y fracciones de días.

TotalHours

Obtiene el valor de la estructura TimeSpan actual, expresado en horas completas y fracciones de horas.

TotalMicroseconds

Obtiene el valor de la estructura actual TimeSpan expresada en microsegundos enteros y fraccionarios.

TotalMilliseconds

Obtiene el valor de la estructura TimeSpan actual, expresado en milisegundos completos y fracciones de milisegundos.

TotalMinutes

Obtiene el valor de la estructura TimeSpan actual, expresado en minutos completos y fracciones de minutos.

TotalNanoseconds

Obtiene el valor de la estructura actual TimeSpan expresada en nanosegundos enteros y fraccionarios.

TotalSeconds

Obtiene el valor de la estructura TimeSpan actual, expresado en segundos completos y fracciones de segundos.

Métodos

Add(TimeSpan)

Devuelve un nuevo objeto TimeSpan cuyo valor es la suma del objeto TimeSpan especificado y esta instancia.

Compare(TimeSpan, TimeSpan)

Compara dos valores TimeSpan 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 la instancia es más corta, igual o más larga que el objeto especificado.

CompareTo(TimeSpan)

Compara esta instancia con un objeto TimeSpan especificado y devuelve un entero que indica si la instancia es más corta, igual o más larga que el objeto TimeSpan.

Divide(Double)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de la división de esta instancia y el valor divisor especificado.

Divide(TimeSpan)

Devuelve un nuevo valor Double que es el resultado de la división de esta instancia y el valor ts especificado.

Duration()

Devuelve un nuevo objeto TimeSpan cuyo valor es el valor absoluto del objeto TimeSpan actual.

Equals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.

Equals(TimeSpan)

Devuelve un valor que indica si esta instancia equivale a un objeto TimeSpan especificado.

Equals(TimeSpan, TimeSpan)

Devuelve un valor que indica si dos instancias de TimeSpan especificadas son iguales.

FromDays(Double)

Devuelve un TimeSpan que representa un número de días especificado con una precisión aproximada al milisegundo más cercano.

FromHours(Double)

Devuelve un TimeSpan que representa un número de horas especificado con una precisión aproximada al milisegundo más cercano.

FromMicroseconds(Double)

Devuelve un TimeSpan valor de tipo que representa un número especificado de microsegundos.

FromMilliseconds(Double)

Devuelve un TimeSpan que representa un número de milisegundos especificado.

FromMinutes(Double)

Devuelve un TimeSpan que representa un número de minutos especificado con una precisión aproximada al milisegundo más cercano.

FromSeconds(Double)

Devuelve un TimeSpan que representa un número de segundos especificado con una precisión aproximada al milisegundo más cercano.

FromTicks(Int64)

Devuelve un TimeSpan que representa un tiempo especificado en unidades de paso.

GetHashCode()

Devuelve un código hash para esta instancia.

Multiply(Double)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de la multiplicación de esta instancia y el valor factor especificado.

Negate()

Devuelve un objeto TimeSpan nuevo cuyo valor es el valor negativo de esta instancia.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Convierte la representación de intervalo de un intervalo de tiempo en su valor 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 equivalente de TimeSpan.

Parse(String, IFormatProvider)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando la información de formato específica de la referencia cultural especificada.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

Convierte la representación de carácter de un intervalo de tiempo en su valor 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 equivalente de TimeSpan, usando los formatos y los estilos 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.

ParseExact(String, String, IFormatProvider)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como 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 equivalente de TimeSpan, usando el formato y los estilos 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 el formato especificado.

ParseExact(String, String[], IFormatProvider)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando la matriz de cadenas de formato especificadas 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.

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando los formatos y los estilos 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.

Subtract(TimeSpan)

Devuelve un nuevo objeto TimeSpan cuyo valor es la diferencia entre el objeto TimeSpan especificado y esta instancia.

ToString()

Convierte el valor del objeto TimeSpan actual en su representación de cadena equivalente.

ToString(String)

Convierte el valor del objeto TimeSpan actual en su representación de cadena equivalente usando el formato especificado.

ToString(String, IFormatProvider)

Convierte el valor del objeto TimeSpan actual en la representación de cadena equivalente usando el formato especificado y la información de formato específica de la referencia cultural.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Intenta dar formato al valor de la instancia del número de intervalo de tiempo actual en el intervalo de caracteres proporcionado.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Convierte la representación de intervalo de un intervalo de tiempo en su valor TimeSpan equivalente mediante la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se ha realizado correctamente.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Convierte la representación de intervalo de un intervalo de tiempo en su valor TimeSpan equivalente y devuelve un valor que indica si la conversión se ha realizado correctamente.

TryParse(String, IFormatProvider, TimeSpan)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan usando la información de formato específica de la referencia cultural, 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 equivalente de TimeSpan 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 equivalente de TimeSpan, usando el formato especificado, así como 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 valor TimeSpan equivalente mediante el formato, la información de formato específica de la referencia cultural y los estilos especificados, y devuelve un valor que indica si la conversión se ha realizado 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 equivalente de TimeSpan, usando el formato especificado, así como la información de formatos 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 especificado de un intervalo de tiempo en su equivalente de TimeSpan, usando los formatos y los estilos especificados, así como 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, TimeSpan)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como 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 equivalente de TimeSpan, usando el formato y los estilos especificados, así como 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, TimeSpan)

Convierte la representación de cadena especificada de un intervalo de tiempo en su equivalente de TimeSpan, usando el formato especificado, así como la información de formatos 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 equivalente de TimeSpan, usando los formatos y los estilos especificados, así como 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.

Operadores

Addition(TimeSpan, TimeSpan)

Agrega dos instancias de TimeSpan especificadas.

Division(TimeSpan, Double)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de la división de esta instancia de timeSpan y el valor divisor especificado.

Division(TimeSpan, TimeSpan)

Devuelve un nuevo valor Double que es el resultado de la división de la instancia de t1 y el valor t2 especificado.

Equality(TimeSpan, TimeSpan)

Indica si dos instancias TimeSpan son iguales.

GreaterThan(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es mayor que otro TimeSpan especificado.

GreaterThanOrEqual(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es mayor o igual que otro TimeSpan especificado.

Inequality(TimeSpan, TimeSpan)

Indica si dos instancias de TimeSpan no son iguales.

LessThan(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es menor que otro TimeSpan especificado.

LessThanOrEqual(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es menor o igual que otro TimeSpan especificado.

Multiply(Double, TimeSpan)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de multiplicar el elemento factor especificado por la instancia de timeSpan especificada.

Multiply(TimeSpan, Double)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de multiplicar la instancia de timeSpan especificada por el elemento factorespecificado.

Subtraction(TimeSpan, TimeSpan)

Resta un TimeSpan especificado de otro TimeSpan especificado.

UnaryNegation(TimeSpan)

Devuelve un TimeSpan cuyo valor es el valor negativo de la instancia especificada.

UnaryPlus(TimeSpan)

Devuelve la instancia especificada de TimeSpan.

Implementaciones de interfaz explícitas

IComparable.CompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve un entero que indica si la instancia es más corta, igual o más larga que el objeto especificado.

Se aplica a

Consulte también