TimeSpan TimeSpan TimeSpan TimeSpan Struct

Definición

Representa un intervalo de tiempo. Represents a time interval.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
type TimeSpan = struct
    interface IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IFormattable
Herencia
Atributos
ComVisibleAttribute SerializableAttribute
Implementaciones

Ejemplos

El ejemplo siguiente crea un TimeSpan objeto que representa la diferencia entre dos fechas.The following example instantiates a TimeSpan object that represents the difference between two dates. A continuación, muestra el TimeSpan propiedades del objeto.It then displays the TimeSpan object's properties.

// 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);
// 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.
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 el tiempo transcurrido) que se mide como un número positivo o negativo de días, horas, minutos, segundos y fracciones de segundo.A TimeSpan object represents a time interval (duration of time or elapsed time) that is measured as a positive or negative number of days, hours, minutes, seconds, and fractions of a second. El TimeSpan estructura también puede usarse para representar la hora del día, pero solo si el tiempo está relacionado con una fecha determinada.The TimeSpan structure can also be used to represent the time of day, but only if the time is unrelated to a particular date. En caso contrario, el DateTime o DateTimeOffset estructura debe usarse en su lugar.Otherwise, the DateTime or DateTimeOffset structure should be used instead. (Para obtener más información sobre el uso de la TimeSpan estructura para reflejar la hora del día, vea Choosing Between DateTime, DateTimeOffset, TimeSpan y TimeZoneInfo.)(For more information about using the TimeSpan structure to reflect the time of day, see Choosing Between DateTime, DateTimeOffset, TimeSpan, and TimeZoneInfo.)

Nota

Un TimeSpan valor representa un intervalo de tiempo y puede expresarse como un número determinado de días, horas, minutos, segundos y milisegundos.A TimeSpan value represents a time interval and can be expressed as a particular number of days, hours, minutes, seconds, and milliseconds. Ya que representa un intervalo general sin hacer referencia a un determinado punto inicial o final, no se pueden expresar en términos de años y meses, los cuales tienen un número variable de días.Because it represents a general interval without reference to a particular start or end point, it cannot be expressed in terms of years and months, both of which have a variable number of days. 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 tiempo.It differs from a DateTime value, which represents a date and time without reference to a particular time zone, or a DateTimeOffset value, which represents a specific moment of time.

La mayor unidad de tiempo que el TimeSpan estructura usa para medir la duración es un día.The largest unit of time that the TimeSpan structure uses to measure duration is a day. Intervalos de tiempo se miden en días para mantener la coherencia, porque el número de días en unidades de tiempo, como meses y años, mayores varía.Time intervals are measured in days for consistency, because the number of days in larger units of time, such as months and years, varies.

El valor de un TimeSpan objeto es el número de tics que igualan el intervalo de tiempo representado.The value of a TimeSpan object is the number of ticks that equal the represented time interval. Un TIC es igual a 100 nanosegundos o una diez millonésima de segundo.A tick is equal to 100 nanoseconds, or one ten-millionth of a second. El valor de un TimeSpan objeto puede oscilar entre TimeSpan.MinValue a TimeSpan.MaxValue.The value of a TimeSpan object can range from TimeSpan.MinValue to TimeSpan.MaxValue.

Crear instancias de un valor TimeSpanInstantiating a TimeSpan Value

Puede crear instancias de un TimeSpan valor de varias maneras:You can instantiate a TimeSpan value in a number of ways:

  • Mediante una llamada a su constructor predeterminado implícito.By calling its implicit default constructor. Esto crea un objeto cuyo valor es TimeSpan.Zero, tal y como se muestra en el ejemplo siguiente.This creates an object whose value is TimeSpan.Zero, as the following example shows.

    TimeSpan interval = new TimeSpan();
    Console.WriteLine(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.By calling one of its explicit constructors. En el ejemplo siguiente se inicializa un TimeSpan valor a un número especificado de horas, minutos y segundos.The following example initializes a TimeSpan value to a specified number of hours, minutes, and seconds.

    TimeSpan interval = new TimeSpan(2, 14, 18);
    Console.WriteLine(interval.ToString());              // Displays "02:14:18".
    
    Dim interval As New TimeSpan(2, 14, 18)
    Console.WriteLine(interval.ToString())                ' Displays "02:14:18".
    
  • Mediante una llamada a un método o realizando una operación que devuelve un TimeSpan valor.By calling a method or performing an operation that returns a TimeSpan value. Por ejemplo, puede crear instancias de un TimeSpan valor que representa el intervalo entre dos valores de fecha y hora, como se muestra en el ejemplo siguiente.For example, you can instantiate a TimeSpan value that represents the interval between two date and time values, as the following example shows.

    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
    
    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.You can also initialize a TimeSpan object to a zero time value in this way, as the following example shows.

    using System;
    
    public class Example
    {
       static Random rnd = new Random();
       
       public static void Main()
       {
          TimeSpan timeSpent = TimeSpan.Zero;
    
          timeSpent += GetTimeBeforeLunch();
          timeSpent += GetTimeAfterLunch();
    
          Console.WriteLine("Total time: {0}", timeSpent);
       }
    
       private static TimeSpan GetTimeBeforeLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
       
       private static TimeSpan GetTimeAfterLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
    }
    // 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 valores devueltos por los operadores aritméticos y los métodos de la DateTime, DateTimeOffset, y TimeSpan estructuras.TimeSpan values are returned by arithmetic operators and methods of the DateTime, DateTimeOffset, and TimeSpan structures.

  • Al analizar la representación de cadena de un TimeSpan valor.By parsing the string representation of a TimeSpan value. Puede usar el Parse y TryParse métodos para convertir las cadenas que contienen intervalos de tiempo para TimeSpan valores.You can use the Parse and TryParse methods to convert strings that contain time intervals to TimeSpan values. En el ejemplo siguiente se usa el Parse método para convertir una matriz de cadenas a TimeSpan valores.The following example uses the Parse method to convert an array of strings to TimeSpan values.

    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'  
    
    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 puede analizar y convertir a un TimeSpan valor mediante una llamada a la ParseExact o TryParseExact método.In addition, you can define the precise format of the input string to be parsed and converted to a TimeSpan value by calling the ParseExact or TryParseExact method.

Realizar operaciones en valores TimeSpanPerforming Operations on TimeSpan Values

Puede agregar y sustraer las duraciones de tiempo mediante la Addition y Subtraction operadores, o mediante una llamada a la Add y Subtract métodos.You can add and subtract time durations either by using the Addition and Subtraction operators, or by calling the Add and Subtract methods. También puede comparar dos duraciones de tiempo mediante una llamada a la Compare, CompareTo, y Equals métodos.You can also compare two time durations by calling the Compare, CompareTo, and Equals methods. El TimeSpan estructura también incluye el Duration y Negate métodos que convierten intervalos de tiempo a valores positivos y negativos,The TimeSpan structure also includes the Duration and Negate methods, which convert time intervals to positive and negative values,

El intervalo de TimeSpan valores es MinValue a MaxValue.The range of TimeSpan values is MinValue to MaxValue.

Dar formato a un valor de intervalo de tiempoFormatting a TimeSpan Value

Un TimeSpan valor se puede representar como [-]d..* hh:mm:ss. FF*, donde el signo menos opcional indica un intervalo de tiempo negativo, el d. es el componente de día, hh son las horas en un reloj de 24 horas, mm es minutos, ss es segundos, y ff fracciones de segundo.A TimeSpan value can be represented as [-]d.hh:mm:ss.ff, where the optional minus sign indicates a negative time interval, the d component is days, hh is hours as measured on a 24-hour clock, mm is minutes, ss is seconds, and ff is fractions of a second. Es decir, un intervalo de tiempo está formado por 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.That is, a time interval consists of a positive or negative number of days without a time of day, or a number of days with a time of day, or only a time of day.

A partir del .NET Framework 4.NET Framework 4, el TimeSpan estructura es compatible con el formato dependiente de la referencia cultural a través de las sobrecargas de su ToString método, que convierte un TimeSpan valor a su representación de cadena.Beginning with the .NET Framework 4.NET Framework 4, the TimeSpan structure supports culture-sensitive formatting through the overloads of its ToString method, which converts a TimeSpan value to its string representation. El valor predeterminado TimeSpan.ToString() método devuelve un intervalo de tiempo con un formato invariable que es idéntico al valor devuelto en versiones anteriores de .NET Framework.The default TimeSpan.ToString() method returns a time interval by using an invariant format that is identical to its return value in previous versions of the .NET Framework. El TimeSpan.ToString(String) sobrecarga permite especificar una cadena de formato que define la representación de cadena del intervalo de tiempo.The TimeSpan.ToString(String) overload lets you specify a format string that defines the string representation of the time interval. El TimeSpan.ToString(String, IFormatProvider) sobrecarga permite especificar una cadena de formato y la referencia cultural cuyas convenciones de formato se utilizan para crear la representación de cadena del intervalo de tiempo.The TimeSpan.ToString(String, IFormatProvider) overload lets you specify a format string and the culture whose formatting conventions are used to create the string representation of the time interval. TimeSpan admite ambas cadenas de formato estándar y personalizados.TimeSpan supports both standard and custom format strings. (Para obtener más información, consulte cadenas de formato TimeSpan estándar y Custom TimeSpan Format Strings.) Sin embargo, solo las cadenas de formato estándar son referencias culturales.(For more information, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.) However, only standard format strings are culture-sensitive.

Restaurar el formato de TimeSpan heredadoRestoring Legacy TimeSpan Formatting

En algunos casos, el código es correctamente formatos TimeSpan valores en .NET Framework 3,5.NET Framework 3.5 y se produce un error en las versiones anteriores en .NET Framework 4.NET Framework 4.In some cases, code that successfully formats TimeSpan values in .NET Framework 3,5.NET Framework 3.5 and earlier versions fails in .NET Framework 4.NET Framework 4. Esto es muy habitual en el código que llama a un elemento < TimeSpan_LegacyFormatMode > método para dar formato a un TimeSpan valor con una cadena de formato.This is most common in code that calls a <TimeSpan_LegacyFormatMode> element method to format a TimeSpan value with a format string. El ejemplo siguiente se da formato correctamente un TimeSpan valor en .NET Framework 3,5.NET Framework 3.5 y versiones anteriores, pero produce una excepción .NET Framework 4.NET Framework 4 y versiones posteriores.The following example successfully formats a TimeSpan value in .NET Framework 3,5.NET Framework 3.5 and earlier versions, but throws an exception in .NET Framework 4.NET Framework 4 and later versions. Tenga en cuenta que intenta dar formato a un TimeSpan valor mediante el uso de un especificador de formato no admitido, que se omite en .NET Framework 3,5.NET Framework 3.5 y versiones anteriores.Note that it attempts to format a TimeSpan value by using an unsupported format specifier, which is ignored in .NET Framework 3,5.NET Framework 3.5 and earlier versions.

TimeSpan interval = new TimeSpan(12, 30, 45);
string output;
try {
   output = String.Format("{0:r}", interval);
}
catch (FormatException) {
   output = "Invalid Format";
}
Console.WriteLine(output);
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format
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 se puede modificar el código, puede restaurar el formato heredado de TimeSpan valores en una de las maneras siguientes:If you cannot modify the code, you can restore the legacy formatting of TimeSpan values in one of the following ways:

  • Mediante la creación de un archivo de configuración que contiene el elemento < TimeSpan_LegacyFormatMode >.By creating a configuration file that contains the <TimeSpan_LegacyFormatMode> element. Establecer este elemento enabled atributo true restaura heredado TimeSpan según la aplicación de formato.Setting this element's enabled attribute to true restores legacy TimeSpan formatting on a per-application basis.

  • Al establecer la compatibilidad de "NetFx40_TimeSpanLegacyFormatMode" cambiar cuando se crea un dominio de aplicación.By setting the "NetFx40_TimeSpanLegacyFormatMode" compatibility switch when you create an application domain. Esto permite heredado TimeSpan formato según el dominio de aplicación.This enables legacy TimeSpan formatting on a per-application-domain basis. El ejemplo siguiente crea un dominio de aplicación que usa heredado TimeSpan formato.The following example creates an application domain that uses legacy TimeSpan formatting.

    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");
       }
    }
    
    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 se ejecuta el código siguiente en el nuevo dominio de aplicación, vuelve a heredado TimeSpan comportamiento de formato.When the following code executes in the new application domain, it reverts to legacy TimeSpan formatting behavior.

    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.
    
    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(Int64) TimeSpan(Int64) TimeSpan(Int64) TimeSpan(Int64)

Inicializa una nueva instancia de la estructura TimeSpan en un número de pasos especificado. Initializes a new instance of the TimeSpan structure to the specified number of ticks.

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

Inicializa una nueva instancia de la estructura TimeSpan con un número de horas, minutos y segundos especificado. Initializes a new instance of the TimeSpan structure to a specified number of hours, minutes, and seconds.

TimeSpan(Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32) 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. Initializes a new instance of the TimeSpan structure to a specified number of days, hours, minutes, and seconds.

TimeSpan(Int32, Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32, Int32) TimeSpan(Int32, Int32, Int32, Int32, Int32) 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. Initializes a new instance of the TimeSpan structure to a specified number of days, hours, minutes, seconds, and milliseconds.

Campos

MaxValue MaxValue MaxValue MaxValue

Representa el valor máximo de TimeSpan. Represents the maximum TimeSpan value. Este campo es de solo lectura. This field is read-only.

MinValue MinValue MinValue MinValue

Representa el valor mínimo de TimeSpan. Represents the minimum TimeSpan value. Este campo es de solo lectura. This field is read-only.

TicksPerDay TicksPerDay TicksPerDay TicksPerDay

Representa el número de pasos en 1 día. Represents the number of ticks in 1 day. Este campo es constante. This field is constant.

TicksPerHour TicksPerHour TicksPerHour TicksPerHour

Representa el número de pasos en 1 hora. Represents the number of ticks in 1 hour. Este campo es constante. This field is constant.

TicksPerMillisecond TicksPerMillisecond TicksPerMillisecond TicksPerMillisecond

Representa el número de pasos en 1 milisegundo. Represents the number of ticks in 1 millisecond. Este campo es constante. This field is constant.

TicksPerMinute TicksPerMinute TicksPerMinute TicksPerMinute

Representa el número de pasos en 1 minuto. Represents the number of ticks in 1 minute. Este campo es constante. This field is constant.

TicksPerSecond TicksPerSecond TicksPerSecond TicksPerSecond

Representa el número de pasos en 1 segundo. Represents the number of ticks in 1 second.

Zero Zero Zero Zero

Representa el valor cero de TimeSpan. Represents the zero TimeSpan value. Este campo es de solo lectura. This field is read-only.

Propiedades

Days Days Days Days

Obtiene el componente de días del intervalo de tiempo representado por la estructura TimeSpan actual. Gets the days component of the time interval represented by the current TimeSpan structure.

Hours Hours Hours Hours

Obtiene el componente de días del intervalo de tiempo representado por la estructura TimeSpan actual. Gets the hours component of the time interval represented by the current TimeSpan structure.

Milliseconds Milliseconds Milliseconds Milliseconds

Obtiene el componente de milisegundos del intervalo de tiempo representado por la estructura TimeSpan actual. Gets the milliseconds component of the time interval represented by the current TimeSpan structure.

Minutes Minutes Minutes Minutes

Obtiene el componente de minutos del intervalo de tiempo representado por la estructura TimeSpan actual. Gets the minutes component of the time interval represented by the current TimeSpan structure.

Seconds Seconds Seconds Seconds

Obtiene el componente de segundos del intervalo de tiempo representado por la estructura TimeSpan actual. Gets the seconds component of the time interval represented by the current TimeSpan structure.

Ticks Ticks Ticks Ticks

Obtiene el número de pasos que representa el valor de la estructura TimeSpan actual. Gets the number of ticks that represent the value of the current TimeSpan structure.

TotalDays TotalDays TotalDays TotalDays

Obtiene el valor de la estructura TimeSpan actual, expresado en días completos y fracciones de días. Gets the value of the current TimeSpan structure expressed in whole and fractional days.

TotalHours TotalHours TotalHours TotalHours

Obtiene el valor de la estructura TimeSpan actual, expresado en horas completas y fracciones de horas. Gets the value of the current TimeSpan structure expressed in whole and fractional hours.

TotalMilliseconds TotalMilliseconds TotalMilliseconds TotalMilliseconds

Obtiene el valor de la estructura TimeSpan actual, expresado en milisegundos completos y fracciones de milisegundos. Gets the value of the current TimeSpan structure expressed in whole and fractional milliseconds.

TotalMinutes TotalMinutes TotalMinutes TotalMinutes

Obtiene el valor de la estructura TimeSpan actual, expresado en minutos completos y fracciones de minutos. Gets the value of the current TimeSpan structure expressed in whole and fractional minutes.

TotalSeconds TotalSeconds TotalSeconds TotalSeconds

Obtiene el valor de la estructura TimeSpan actual, expresado en segundos completos y fracciones de segundos. Gets the value of the current TimeSpan structure expressed in whole and fractional seconds.

Métodos

Add(TimeSpan) Add(TimeSpan) Add(TimeSpan) Add(TimeSpan)

Devuelve un nuevo objeto TimeSpan cuyo valor es la suma del objeto TimeSpan especificado y esta instancia. Returns a new TimeSpan object whose value is the sum of the specified TimeSpan object and this instance.

Compare(TimeSpan, TimeSpan) Compare(TimeSpan, TimeSpan) Compare(TimeSpan, TimeSpan) 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. Compares two TimeSpan values and returns an integer that indicates whether the first value is shorter than, equal to, or longer than the second value.

CompareTo(Object) CompareTo(Object) CompareTo(Object) 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. Compares this instance to a specified object and returns an integer that indicates whether this instance is shorter than, equal to, or longer than the specified object.

CompareTo(TimeSpan) CompareTo(TimeSpan) CompareTo(TimeSpan) 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. Compares this instance to a specified TimeSpan object and returns an integer that indicates whether this instance is shorter than, equal to, or longer than the TimeSpan object.

Divide(TimeSpan) Divide(TimeSpan) Divide(TimeSpan) Divide(TimeSpan)
Divide(Double) Divide(Double) Divide(Double) Divide(Double)
Duration() Duration() Duration() Duration()

Devuelve un nuevo objeto TimeSpan cuyo valor es el valor absoluto del objeto TimeSpan actual. Returns a new TimeSpan object whose value is the absolute value of the current TimeSpan object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado. Returns a value indicating whether this instance is equal to a specified object.

Equals(TimeSpan) Equals(TimeSpan) Equals(TimeSpan) Equals(TimeSpan)

Devuelve un valor que indica si esta instancia equivale a un objeto TimeSpan especificado. Returns a value indicating whether this instance is equal to a specified TimeSpan object.

Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan)

Devuelve un valor que indica si dos instancias de TimeSpan especificadas son iguales. Returns a value that indicates whether two specified instances of TimeSpan are equal.

FromDays(Double) FromDays(Double) FromDays(Double) FromDays(Double)

Devuelve un TimeSpan que representa un número de días especificado con una precisión aproximada al milisegundo más cercano. Returns a TimeSpan that represents a specified number of days, where the specification is accurate to the nearest millisecond.

FromHours(Double) FromHours(Double) FromHours(Double) FromHours(Double)

Devuelve un TimeSpan que representa un número de horas especificado con una precisión aproximada al milisegundo más cercano. Returns a TimeSpan that represents a specified number of hours, where the specification is accurate to the nearest millisecond.

FromMilliseconds(Double) FromMilliseconds(Double) FromMilliseconds(Double) FromMilliseconds(Double)

Devuelve un TimeSpan que representa un número de milisegundos especificado. Returns a TimeSpan that represents a specified number of milliseconds.

FromMinutes(Double) FromMinutes(Double) FromMinutes(Double) FromMinutes(Double)

Devuelve un TimeSpan que representa un número de minutos especificado con una precisión aproximada al milisegundo más cercano. Returns a TimeSpan that represents a specified number of minutes, where the specification is accurate to the nearest millisecond.

FromSeconds(Double) FromSeconds(Double) FromSeconds(Double) FromSeconds(Double)

Devuelve un TimeSpan que representa un número de segundos especificado con una precisión aproximada al milisegundo más cercano. Returns a TimeSpan that represents a specified number of seconds, where the specification is accurate to the nearest millisecond.

FromTicks(Int64) FromTicks(Int64) FromTicks(Int64) FromTicks(Int64)

Devuelve un TimeSpan que representa un tiempo especificado en unidades de paso. Returns a TimeSpan that represents a specified time, where the specification is in units of ticks.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Devuelve un código hash para esta instancia. Returns a hash code for this instance.

Multiply(Double) Multiply(Double) Multiply(Double) Multiply(Double)
Negate() Negate() Negate() Negate()

Devuelve un objeto TimeSpan nuevo cuyo valor es el valor negativo de esta instancia. Returns a new TimeSpan object whose value is the negated value of this instance.

Parse(String) Parse(String) Parse(String) Parse(String)

Convierte la representación de cadena de un intervalo de tiempo en su equivalente de TimeSpan. Converts the string representation of a time interval to its TimeSpan equivalent.

Parse(ReadOnlySpan<Char>, IFormatProvider) Parse(ReadOnlySpan<Char>, IFormatProvider) Parse(ReadOnlySpan<Char>, IFormatProvider) Parse(ReadOnlySpan<Char>, IFormatProvider)
Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified culture-specific format information.

ParseExact(String, String, IFormatProvider, TimeSpanStyles) ParseExact(String, String, IFormatProvider, TimeSpanStyles) ParseExact(String, String, IFormatProvider, TimeSpanStyles) 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. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. The format of the string representation must match the specified format exactly.

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles) ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)
ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) ParseExact(String, String[], IFormatProvider, TimeSpanStyles) 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. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. The format of the string representation must match one of the specified formats exactly.

ParseExact(String, String[], IFormatProvider) ParseExact(String, String[], IFormatProvider) ParseExact(String, String[], IFormatProvider) 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. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified array of format strings and culture-specific format information. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. The format of the string representation must match one of the specified formats exactly.

ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) ParseExact(String, String, IFormatProvider) 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. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. The format of the string representation must match the specified format exactly.

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

Devuelve un nuevo objeto TimeSpan cuyo valor es la diferencia entre el objeto TimeSpan especificado y esta instancia. Returns a new TimeSpan object whose value is the difference between the specified TimeSpan object and this instance.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) 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. Converts the value of the current TimeSpan object to its equivalent string representation by using the specified format and culture-specific formatting information.

ToString(String) ToString(String) ToString(String) ToString(String)

Convierte el valor del objeto TimeSpan actual en su representación de cadena equivalente usando el formato especificado. Converts the value of the current TimeSpan object to its equivalent string representation by using the specified format.

ToString() ToString() ToString() ToString()

Convierte el valor del objeto TimeSpan actual en su representación de cadena equivalente. Converts the value of the current TimeSpan object to its equivalent string representation.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan) TryParse(ReadOnlySpan<Char>, TimeSpan)
TryParse(String, TimeSpan) TryParse(String, TimeSpan) TryParse(String, TimeSpan) 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. Converts the string representation of a time interval to its TimeSpan equivalent and returns a value that indicates whether the conversion succeeded.

TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan) TryParse(String, IFormatProvider, TimeSpan) 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. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified culture-specific formatting information, and returns a value that indicates whether the conversion succeeded.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan) 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, y la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se realizó correctamente. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. The format of the string representation must match the specified format exactly.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)
TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpan)

Convierte la representación de cadena especificada de un intervalo de tiempo en su equivalente de TimeSpan usando los formatos especificados y la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se realizó correctamente. Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats and culture-specific format information, and returns a value that indicates whether the conversion succeeded. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. The format of the string representation must match one of the specified formats exactly.

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan) 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, y la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se realizó correctamente. Converts the specified string representation of a time interval to its TimeSpan equivalent by using the specified formats, culture-specific format information, and styles, and returns a value that indicates whether the conversion succeeded. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados. The format of the string representation must match one of the specified formats exactly.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan) TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)
TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) TryParseExact(String, String, IFormatProvider, TimeSpan) 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 y la información de formato específica de la referencia cultural, y devuelve un valor que indica si la conversión se realizó correctamente. Converts the string representation of a time interval to its TimeSpan equivalent by using the specified format and culture-specific format information, and returns a value that indicates whether the conversion succeeded. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. The format of the string representation must match the specified format exactly.

Operadores

Addition(TimeSpan, TimeSpan) Addition(TimeSpan, TimeSpan) Addition(TimeSpan, TimeSpan) Addition(TimeSpan, TimeSpan)

Agrega dos instancias de TimeSpan especificadas. Adds two specified TimeSpan instances.

Division(TimeSpan, TimeSpan) Division(TimeSpan, TimeSpan) Division(TimeSpan, TimeSpan) Division(TimeSpan, TimeSpan)
Division(TimeSpan, Double) Division(TimeSpan, Double) Division(TimeSpan, Double) Division(TimeSpan, Double)
Equality(TimeSpan, TimeSpan) Equality(TimeSpan, TimeSpan) Equality(TimeSpan, TimeSpan) Equality(TimeSpan, TimeSpan)

Indica si dos instancias TimeSpan son iguales. Indicates whether two TimeSpan instances are equal.

GreaterThan(TimeSpan, TimeSpan) GreaterThan(TimeSpan, TimeSpan) GreaterThan(TimeSpan, TimeSpan) GreaterThan(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es mayor que otro TimeSpan especificado. Indicates whether a specified TimeSpan is greater than another specified TimeSpan.

GreaterThanOrEqual(TimeSpan, TimeSpan) GreaterThanOrEqual(TimeSpan, TimeSpan) GreaterThanOrEqual(TimeSpan, TimeSpan) GreaterThanOrEqual(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es mayor o igual que otro TimeSpan especificado. Indicates whether a specified TimeSpan is greater than or equal to another specified TimeSpan.

Inequality(TimeSpan, TimeSpan) Inequality(TimeSpan, TimeSpan) Inequality(TimeSpan, TimeSpan) Inequality(TimeSpan, TimeSpan)

Indica si dos instancias de TimeSpan no son iguales. Indicates whether two TimeSpan instances are not equal.

LessThan(TimeSpan, TimeSpan) LessThan(TimeSpan, TimeSpan) LessThan(TimeSpan, TimeSpan) LessThan(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es menor que otro TimeSpan especificado. Indicates whether a specified TimeSpan is less than another specified TimeSpan.

LessThanOrEqual(TimeSpan, TimeSpan) LessThanOrEqual(TimeSpan, TimeSpan) LessThanOrEqual(TimeSpan, TimeSpan) LessThanOrEqual(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es menor o igual que otro TimeSpan especificado. Indicates whether a specified TimeSpan is less than or equal to another specified TimeSpan.

Multiply(Double, TimeSpan) Multiply(Double, TimeSpan) Multiply(Double, TimeSpan) Multiply(Double, TimeSpan)
Multiply(TimeSpan, Double) Multiply(TimeSpan, Double) Multiply(TimeSpan, Double) Multiply(TimeSpan, Double)
Subtraction(TimeSpan, TimeSpan) Subtraction(TimeSpan, TimeSpan) Subtraction(TimeSpan, TimeSpan) Subtraction(TimeSpan, TimeSpan)

Resta un TimeSpan especificado de otro TimeSpan especificado. Subtracts a specified TimeSpan from another specified TimeSpan.

UnaryNegation(TimeSpan) UnaryNegation(TimeSpan) UnaryNegation(TimeSpan) UnaryNegation(TimeSpan)

Devuelve un TimeSpan cuyo valor es el valor negativo de la instancia especificada. Returns a TimeSpan whose value is the negated value of the specified instance.

UnaryPlus(TimeSpan) UnaryPlus(TimeSpan) UnaryPlus(TimeSpan) UnaryPlus(TimeSpan)

Devuelve la instancia especificada de TimeSpan. Returns the specified instance of TimeSpan.

Implementaciones de interfaz explícitas

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)

Se aplica a

Consultar también