TimeSpan Estructura
TOC
Collapse the table of content
Expand the table of content
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

TimeSpan (Estructura)

 

Representa un intervalo de tiempo.

Para examinar el código fuente de .NET Framework de este tipo, consulte el origen de referencia.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, 
	IEquatable<TimeSpan>, IFormattable

NombreDescripción
System_CAPS_pubmethodTimeSpan(Int32, Int32, Int32)

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

System_CAPS_pubmethodTimeSpan(Int32, Int32, Int32, Int32)

Initializes a new instance of the TimeSpan structure to a specified number of days, hours, minutes, and seconds.

System_CAPS_pubmethodTimeSpan(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.

System_CAPS_pubmethodTimeSpan(Int64)

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

NombreDescripción
System_CAPS_pubpropertyDays

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

System_CAPS_pubpropertyHours

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

System_CAPS_pubpropertyMilliseconds

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

System_CAPS_pubpropertyMinutes

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

System_CAPS_pubpropertySeconds

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

System_CAPS_pubpropertyTicks

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

System_CAPS_pubpropertyTotalDays

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

System_CAPS_pubpropertyTotalHours

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

System_CAPS_pubpropertyTotalMilliseconds

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

System_CAPS_pubpropertyTotalMinutes

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

System_CAPS_pubpropertyTotalSeconds

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

NombreDescripción
System_CAPS_pubmethodAdd(TimeSpan)

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

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodDuration()

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

System_CAPS_pubmethodEquals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.(Reemplaza a ValueType.Equals(Object)).

System_CAPS_pubmethodEquals(TimeSpan)

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

System_CAPS_pubmethodSystem_CAPS_staticEquals(TimeSpan, TimeSpan)

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

System_CAPS_pubmethodSystem_CAPS_staticFromDays(Double)

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

System_CAPS_pubmethodSystem_CAPS_staticFromHours(Double)

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

System_CAPS_pubmethodSystem_CAPS_staticFromMilliseconds(Double)

Returns a TimeSpan that represents a specified number of milliseconds.

System_CAPS_pubmethodSystem_CAPS_staticFromMinutes(Double)

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

System_CAPS_pubmethodSystem_CAPS_staticFromSeconds(Double)

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

System_CAPS_pubmethodSystem_CAPS_staticFromTicks(Int64)

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

System_CAPS_pubmethodGetHashCode()

Devuelve un código hash para esta instancia.(Reemplaza a ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual. (Heredado de Object.)

System_CAPS_pubmethodNegate()

Returns a new TimeSpan object whose value is the negated value of this instance.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(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.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(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.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(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.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(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.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(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.

System_CAPS_pubmethodSubtract(TimeSpan)

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

System_CAPS_pubmethodToString()

Convierte el valor del objeto TimeSpan actual en su representación de cadena equivalente.(Reemplaza a ValueType.ToString()).

System_CAPS_pubmethodToString(String)

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

System_CAPS_pubmethodToString(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(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.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(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. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(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. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(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. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(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. El formato de la representación de cadena debe coincidir exactamente con uno de los formatos especificados.

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

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

System_CAPS_pubfieldSystem_CAPS_staticMinValue

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

System_CAPS_pubfieldSystem_CAPS_staticTicksPerDay

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

System_CAPS_pubfieldSystem_CAPS_staticTicksPerHour

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

System_CAPS_pubfieldSystem_CAPS_staticTicksPerMillisecond

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

System_CAPS_pubfieldSystem_CAPS_staticTicksPerMinute

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

System_CAPS_pubfieldSystem_CAPS_staticTicksPerSecond

Representa el número de pasos en 1 segundo.

System_CAPS_pubfieldSystem_CAPS_staticZero

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

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticAddition(TimeSpan, TimeSpan)

Agrega dos instancias de TimeSpan especificadas.

System_CAPS_puboperatorSystem_CAPS_staticEquality(TimeSpan, TimeSpan)

Indica si dos instancias TimeSpan son iguales.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(TimeSpan, TimeSpan)

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

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(TimeSpan, TimeSpan)

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

System_CAPS_puboperatorSystem_CAPS_staticInequality(TimeSpan, TimeSpan)

Indica si dos instancias de TimeSpan no son iguales.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(TimeSpan, TimeSpan)

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

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(TimeSpan, TimeSpan)

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

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(TimeSpan, TimeSpan)

Resta un TimeSpan especificado de otro TimeSpan especificado.

System_CAPS_puboperatorSystem_CAPS_staticUnaryNegation(TimeSpan)

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

System_CAPS_puboperatorSystem_CAPS_staticUnaryPlus(TimeSpan)

Devuelve la instancia especificada de TimeSpan.

System_CAPS_noteNota

To view the .NET Framework source code for this type, see the Reference Sourcehttp://referencesource.microsoft.com/#mscorlib/system/timespan.cs#865ef7b89f41b632. You can browse through the source code online, download the reference for offline viewing, and step through the sources (including patches and updates) during debugging; see instructionshttp://referencesource.microsoft.com/.

A T:System.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. The T:System.TimeSpan structure can also be used to represent the time of day, but only if the time is unrelated to a particular date. Otherwise, the T:System.DateTime or T:System.DateTimeOffset structure should be used instead. (For more information about using the T:System.TimeSpan structure to reflect the time of day, see Choosing Between DateTime, DateTimeOffset, TimeSpan, and TimeZoneInfo.)

System_CAPS_noteNota

A T:System.TimeSpan value represents a time interval and can be expressed as a particular number of days, hours, minutes, seconds, and milliseconds. 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. It differs from a T:System.DateTime value, which represents a date and time without reference to a particular time zone, or a T:System.DateTimeOffset value, which represents a specific moment of time.

The largest unit of time that the T:System.TimeSpan structure uses to measure duration is a day. Time intervals are measured in days for consistency, because the number of days in larger units of time, such as months and years, varies.

The value of a T:System.TimeSpan object is the number of ticks that equal the represented time interval. A tick is equal to 100 nanoseconds, or one ten-millionth of a second. The value of a T:System.TimeSpan object can range from F:System.TimeSpan.MinValue to F:System.TimeSpan.MaxValue.

You can instantiate a T:System.TimeSpan value in a number of ways:

  • By calling its implicit default constructor. This creates an object whose value is F:System.TimeSpan.Zero, as the following example shows.

    TimeSpan interval = new TimeSpan();
    Console.WriteLine(interval.Equals(TimeSpan.Zero));    // Displays "True".
    
  • By calling one of its explicit constructors. The following example initializes a T:System.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".
    
  • By calling a method or performing an operation that returns a T:System.TimeSpan value. For example, you can instantiate a T:System.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
    

    You can also initialize a T:System.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
    

    TimeSpan values are returned by arithmetic operators and methods of the DateTime, DateTimeOffset, and TimeSpan structures.

  • By parsing the string representation of a T:System.TimeSpan value. You can use the M:System.TimeSpan.Parse(System.String) and M:System.TimeSpan.TryParse(System.String,System.TimeSpan@) methods to convert strings that contain time intervals to T:System.TimeSpan values. The following example uses the M:System.TimeSpan.Parse(System.String) method to convert an array of strings to T:System.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'  
    

    In addition, you can define the precise format of the input string to be parsed and converted to a T:System.TimeSpan value by calling the Overload:System.TimeSpan.ParseExact or Overload:System.TimeSpan.TryParseExact method.

You can add and subtract time durations either by using the M:System.TimeSpan.op_Addition(System.TimeSpan,System.TimeSpan) and M:System.TimeSpan.op_Subtraction(System.TimeSpan,System.TimeSpan) operators, or by calling the M:System.TimeSpan.Add(System.TimeSpan) and M:System.TimeSpan.Subtract(System.TimeSpan) methods. You can also compare two time durations by calling the M:System.TimeSpan.Compare(System.TimeSpan,System.TimeSpan), Overload:System.TimeSpan.CompareTo, and Overload:System.TimeSpan.Equals methods. The T:System.TimeSpan structure also includes the M:System.TimeSpan.Duration and M:System.TimeSpan.Negate methods, which convert time intervals to positive and negative values,

The range of T:System.TimeSpan values is F:System.TimeSpan.MinValue to F:System.TimeSpan.MaxValue.

A T:System.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. 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.

Beginning with the net_v40_long, the T:System.TimeSpan structure supports culture-sensitive formatting through the overloads of its M:System.TimeSpan.ToString(System.String,System.IFormatProvider) method, which converts a T:System.TimeSpan value to its string representation. The default M:System.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. The M:System.TimeSpan.ToString(System.String) overload lets you specify a format string that defines the string representation of the time interval. The M:System.TimeSpan.ToString(System.String,System.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. T:System.TimeSpan supports both standard and custom format strings. (For more information, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.) However, only standard format strings are culture-sensitive.

In some cases, code that successfully formats T:System.TimeSpan values in net_v35_short and earlier versions fails in net_v40_short. This is most common in code that calls a method to format a T:System.TimeSpan value with a format string. The following example successfully formats a T:System.TimeSpan value in net_v35_short and earlier versions, but throws an exception in net_v40_short and later versions. Note that it attempts to format a T:System.TimeSpan value by using an unsupported format specifier, which is ignored in net_v35_short 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

If you cannot modify the code, you can restore the legacy formatting of T:System.TimeSpan values in one of the following ways:

  • By creating a configuration file that contains the . Setting this element's enabled attribute to true restores legacy T:System.TimeSpan formatting on a per-application basis.

  • By setting the "NetFx40_TimeSpanLegacyFormatMode" compatibility switch when you create an application domain. This enables legacy T:System.TimeSpan formatting on a per-application-domain basis. The following example creates an application domain that uses legacy T:System.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");
       }
    }
    

    When the following code executes in the new application domain, it reverts to legacy T:System.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.
    

The following example instantiates a T:System.TimeSpan object that represents the difference between two dates. It then displays the T:System.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

Universal Windows Platform
Disponible desde 4.5
.NET Framework
Disponible desde 1.1
Portable Class Library
Compatible con: portable .NET platforms
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Volver al principio
Mostrar:
© 2016 Microsoft