TimeSpan Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

TimeSpan.cs

Representa un intervalo de tiempo.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable

type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
    interface IUtf8SpanFormattable

Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan), IUtf8SpanFormattable

Herencia

Object

ValueType

TimeSpan

Implementaciones

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

Ejemplos

En el ejemplo siguiente se crea una instancia de un TimeSpan objeto que representa la diferencia entre dos fechas. A continuación, muestra las TimeSpan propiedades del objeto.

// Define two dates.
DateTime date1 = new DateTime(2010, 1, 1, 8, 0, 15);
DateTime date2 = new DateTime(2010, 8, 18, 13, 30, 30);

// Calculate the interval between the two dates.
TimeSpan interval = date2 - date1;
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString());

// Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays);
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours);
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks);

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000

// Define two dates.
let date1 = DateTime(2010, 1, 1, 8, 0, 15)
let date2 = DateTime(2010, 8, 18, 13, 30, 30)

// Calculate the interval between the two dates.
let interval = date2 - date1
printfn $"{date2} - {date1} = {interval}"

// Display individual properties of the resulting TimeSpan object.
printfn $"""   {"Value of Days Component:",-35} {interval.Days,20}""" 
printfn $"""   {"Total Number of Days:",-35} {interval.TotalDays,20}""" 
printfn $"""   {"Value of Hours Component:",-35} {interval.Hours,20}""" 
printfn $"""   {"Total Number of Hours:",-35} {interval.TotalHours,20}""" 
printfn $"""   {"Value of Minutes Component:",-35} {interval.Minutes,20}""" 
printfn $"""   {"Total Number of Minutes:",-35} {interval.TotalMinutes,20}""" 
printfn $"""   {"Value of Seconds Component:",-35} {interval.Seconds,20:N0}""" 
printfn $"""   {"Total Number of Seconds:",-35} {interval.TotalSeconds,20:N0}""" 
printfn $"""   {"Value of Milliseconds Component:",-35} {interval.Milliseconds,20:N0}""" 
printfn $"""   {"Total Number of Milliseconds:",-35} {interval.TotalMilliseconds,20:N0}""" 
printfn $"""   {"Ticks:",-35} {interval.Ticks,20:N0}""" 

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000

' Define two dates.
Dim date1 As Date = #1/1/2010 8:00:15AM#
Dim date2 As Date = #8/18/2010 1:30:30PM#
' Calculate the interval between the two dates.
Dim interval As TimeSpan = date2 - date1
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString())
' Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays)
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours)
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks)
' The example displays the following output:
'       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
'          Value of Days Component:                             229
'          Total Number of Days:                   229.229340277778
'          Value of Hours Component:                              5
'          Total Number of Hours:                  5501.50416666667
'          Value of Minutes Component:                           30
'          Total Number of Minutes:                       330090.25
'          Value of Seconds Component:                           15
'          Total Number of Seconds:                      19,805,415
'          Value of Milliseconds Component:                       0
'          Total Number of Milliseconds:             19,805,415,000
'          Ticks:                               198,054,150,000,000

# Define two dates.
$Date2 = Get-Date -Date '2010/8/18' -Hour 13 -Minute 30 -Second 30
$Date1 = Get-Date -Date '2010/1/1'  -Hour 8  -Minute 0  -Second 15

# Calculate the interval between the two dates.
$Interval = $Date2 - $Date1
"{0} - {1} = {2}" -f $Date2, $Date1, ($Interval.ToString())

#  Display individual properties of the resulting TimeSpan object.
"   {0,-35} {1,20}"    -f "Value of Days Component:", $Interval.Days
"   {0,-35} {1,20}"    -f "Total Number of Days:", $Interval.TotalDays
"   {0,-35} {1,20}"    -f "Value of Hours Component:", $Interval.Hours
"   {0,-35} {1,20}"    -f "Total Number of Hours:", $Interval.TotalHours
"   {0,-35} {1,20}"    -f "Value of Minutes Component:", $Interval.Minutes
"   {0,-35} {1,20}"    -f "Total Number of Minutes:", $Interval.TotalMinutes
"   {0,-35} {1,20:N0}" -f "Value of Seconds Component:", $Interval.Seconds
"   {0,-35} {1,20:N0}" -f "Total Number of Seconds:", $Interval.TotalSeconds
"   {0,-35} {1,20:N0}" -f "Value of Milliseconds Component:", $Interval.Milliseconds
"   {0,-35} {1,20:N0}" -f "Total Number of Milliseconds:", $Interval.TotalMilliseconds
"   {0,-35} {1,20:N0}" -f "Ticks:", $Interval.Ticks

<# This sample produces the following output:

18/08/2010 13:30:30 - 01/01/2010 08:00:15 = 229.05:30:15
   Value of Days Component:                             229
   Total Number of Days:                   229.229340277778
   Value of Hours Component:                              5
   Total Number of Hours:                  5501.50416666667
   Value of Minutes Component:                           30
   Total Number of Minutes:                       330090.25
   Value of Seconds Component:                           15
   Total Number of Seconds:                      19,805,415
   Value of Milliseconds Component:                       0
   Total Number of Milliseconds:             19,805,415,000
   Ticks:                               198,054,150,000,000
#>

Comentarios

Para obtener más información sobre esta API, consulte Comentarios complementarios de la API para TimeSpan.

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 TimeSpan estructura 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 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 TimeSpan objeto cuyo valor es el resultado de dividir esta instancia por el especificado divisor.
Divide(TimeSpan)	Devuelve un nuevo Double valor que es el resultado de dividir esta instancia por ts.
Duration()	Devuelve un nuevo 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 objeto 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<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 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 TimeSpan objeto cuyo valor es el resultado de dividir el especificado timeSpan por el especificado divisor.
Division(TimeSpan, TimeSpan)	Devuelve un nuevo Double valor que es el resultado de dividir t1 por t2.
Equality(TimeSpan, TimeSpan)	Indica si dos 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.

Consulte también

• DateTime
• DateTimeOffset
• Calendar