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, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
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>
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
[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>
type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
    interface IUtf8SpanFormattable
[<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, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan), IUtf8SpanFormattable
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 objeto TimeSpan que representa la diferencia entre dos fechas. A continuación, muestra las propiedades del objeto TimeSpan.

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

Para obtener más información sobre esta API, consulte comentarios de api complementarias para TimeSpan.

Constructores

TimeSpan(Int32, Int32, Int32)

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

TimeSpan(Int32, Int32, Int32, Int32)

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

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

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

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

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

TimeSpan(Int64)

Inicializa una nueva instancia de la estructura TimeSpan al número especificado de tics.

Campos

HoursPerDay

Representa un intervalo de tiempo.

MaxValue

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

MicrosecondsPerDay

Representa un intervalo de tiempo.

MicrosecondsPerHour

Representa un intervalo de tiempo.

MicrosecondsPerMillisecond

Representa un intervalo de tiempo.

MicrosecondsPerMinute

Representa un intervalo de tiempo.

MicrosecondsPerSecond

Representa un intervalo de tiempo.

MillisecondsPerDay

Representa un intervalo de tiempo.

MillisecondsPerHour

Representa un intervalo de tiempo.

MillisecondsPerMinute

Representa un intervalo de tiempo.

MillisecondsPerSecond

Representa un intervalo de tiempo.

MinutesPerDay

Representa un intervalo de tiempo.

MinutesPerHour

Representa un intervalo de tiempo.

MinValue

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

NanosecondsPerTick

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

SecondsPerDay

Representa un intervalo de tiempo.

SecondsPerHour

Representa un intervalo de tiempo.

SecondsPerMinute

Representa un intervalo de tiempo.

TicksPerDay

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

TicksPerHour

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

TicksPerMicrosecond

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

TicksPerMillisecond

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

TicksPerMinute

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

TicksPerSecond

Representa el número de tics en 1 segundo.

Zero

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

Propiedades

Days

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

Hours

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

Microseconds

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

Milliseconds

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

Minutes

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

Nanoseconds

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

Seconds

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

Ticks

Obtiene el número de tics que representan el valor de la estructura TimeSpan actual.

TotalDays

Obtiene el valor de la estructura TimeSpan actual expresada en días enteros y fraccionarios.

TotalHours

Obtiene el valor de la estructura TimeSpan actual expresada en horas enteras y fraccionarios.

TotalMicroseconds

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

TotalMilliseconds

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

TotalMinutes

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

TotalNanoseconds

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

TotalSeconds

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

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 que, igual o mayor que el segundo valor.

CompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve un entero que indica si esta instancia es menor que, igual o mayor que el objeto especificado.

CompareTo(TimeSpan)

Compara esta instancia con un objeto de TimeSpan especificado y devuelve un entero que indica si esta instancia es menor que, igual o mayor que el objeto TimeSpan.

Divide(Double)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de dividir esta instancia por el divisorespecificado.

Divide(TimeSpan)

Devuelve un nuevo valor de Double que es el resultado de dividir esta instancia por ts.

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 es igual a un objeto especificado.

Equals(TimeSpan)

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

Equals(TimeSpan, TimeSpan)

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

FromDays(Double)

Devuelve un TimeSpan que representa un número especificado de días, donde la especificación es precisa para el milisegundo más cercano.

FromDays(Int32)

Inicializa una nueva instancia de la estructura TimeSpan en un número especificado de días.

FromDays(Int32, Int32, Int64, Int64, Int64, Int64)

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

FromHours(Double)

Devuelve un TimeSpan que representa un número especificado de horas, donde la especificación es precisa para el milisegundo más cercano.

FromHours(Int32)

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

FromHours(Int32, Int64, Int64, Int64, Int64)

Inicializa una nueva instancia de la estructura TimeSpan en un número especificado de horas, minutos, segundos, milisegundos y microsegundos especificados.

FromMicroseconds(Double)

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

FromMicroseconds(Int64)

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

FromMilliseconds(Double)

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

FromMilliseconds(Int64, Int64)

Inicializa una nueva instancia de la estructura TimeSpan en un número especificado de milisegundos y microsegundos.

FromMinutes(Double)

Devuelve un TimeSpan que representa un número especificado de minutos, donde la especificación es precisa para el milisegundo más cercano.

FromMinutes(Int64)

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

FromMinutes(Int64, Int64, Int64, Int64)

Inicializa una nueva instancia de la estructura de TimeSpan en un número especificado de minutos, segundos, milisegundos y microsegundos especificados.

FromSeconds(Double)

Devuelve un TimeSpan que representa un número especificado de segundos, donde la especificación es precisa para el milisegundo más cercano.

FromSeconds(Int64)

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

FromSeconds(Int64, Int64, Int64)

Inicializa una nueva instancia de la estructura de TimeSpan en un número especificado de segundos, milisegundos y microsegundos especificados.

FromTicks(Int64)

Devuelve un TimeSpan que representa un tiempo especificado, donde la especificación está en unidades de tics.

GetHashCode()

Devuelve un código hash para esta instancia.

Multiply(Double)

Devuelve un nuevo objeto TimeSpan que es el resultado de la multiplicación de esta instancia y el factorespecificado.

Negate()

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

Parse(ReadOnlySpan<Char>, IFormatProvider)

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

Parse(String)

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente.

Parse(String, IFormatProvider)

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

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

Convierte el intervalo de caracteres de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

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

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, la información de formato específica de la referencia cultural y los estilos. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

ParseExact(String, String, IFormatProvider)

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado, la información de formato específica de la referencia cultural y los estilos especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

ParseExact(String, String[], IFormatProvider)

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante la matriz especificada de cadenas de formato e información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

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

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, la información de formato específica de la referencia cultural y los estilos. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

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 mediante el formato especificado.

ToString(String, IFormatProvider)

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

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

Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado.

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

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

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

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

TryParse(ReadOnlySpan<Char>, TimeSpan)

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

TryParse(String, IFormatProvider, TimeSpan)

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

TryParse(String, TimeSpan)

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

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado, la información de formato específico de la referencia cultural y los estilos, y devuelve un valor que indica si la conversión se realizó correctamente. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

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

Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

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

Convierte la representación de intervalo especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, la información y los estilos de formato específicos de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

TryParseExact(String, String, IFormatProvider, TimeSpan)

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Convierte la representación de cadena de un intervalo de tiempo en su TimeSpan equivalente mediante el formato especificado, la información y los estilos de formato específicos de la referencia cultural especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

TryParseExact(String, String[], IFormatProvider, TimeSpan)

Convierte la representación de cadena especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados y la información de formato específica de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Convierte la representación de cadena especificada de un intervalo de tiempo en su TimeSpan equivalente mediante los formatos especificados, la información y los estilos de formato específicos de la referencia cultural. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

Operadores

Addition(TimeSpan, TimeSpan)

Agrega dos instancias de TimeSpan especificadas.

Division(TimeSpan, Double)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de dividir el timeSpan especificado por el divisorespecificado.

Division(TimeSpan, TimeSpan)

Devuelve un nuevo valor de Double que es el resultado de dividir t1 por t2.

Equality(TimeSpan, TimeSpan)

Indica si dos instancias de TimeSpan son iguales.

GreaterThan(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es mayor que otro TimeSpanespecificado.

GreaterThanOrEqual(TimeSpan, TimeSpan)

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

Inequality(TimeSpan, TimeSpan)

Indica si dos instancias de TimeSpan no son iguales.

LessThan(TimeSpan, TimeSpan)

Indica si un TimeSpan especificado es menor que otro TimeSpanespecificado.

LessThanOrEqual(TimeSpan, TimeSpan)

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

Multiply(Double, TimeSpan)

Devuelve un nuevo objeto TimeSpan cuyo valor es el resultado de multiplicar el factor especificado y 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 y el factorespecificado.

Subtraction(TimeSpan, TimeSpan)

Resta un TimeSpan especificado de otro TimeSpanespecificado.

UnaryNegation(TimeSpan)

Devuelve un TimeSpan cuyo valor es el valor negado 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 esta instancia es menor que, igual o mayor que el objeto especificado.

Se aplica a

Consulte también