Aplicaciones de Windows
Collapse the table of content
Expand the table of content
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés
Información
El tema que ha solicitado se muestra abajo. Sin embargo, este tema no se encuentra en la biblioteca.

Estructura DateTime

 

Representa un instante de tiempo, normalmente expresado en forma de fecha y hora del día.

Para examinar el código fuente de .NET Framework para este tipo, vea la Reference Source.

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

[SerializableAttribute]
public struct DateTime : IComparable, IFormattable, IConvertible, 
	ISerializable, IComparable<DateTime>, IEquatable<DateTime>

NombreDescripción
System_CAPS_pubmethodDateTime(Int32, Int32, Int32)

Inicializa una nueva instancia de la estructura DateTime en el año, mes y día especificados.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Calendar)

Inicializa una nueva instancia de la estructura DateTime en el año, mes y día especificados para el calendario determinado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto y segundo especificados.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto y segundo especificados para el calendario indicado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo y hora universal coordinada (UTC) u hora local especificados.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo y milisegundo especificados.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo y milisegundo especificados para el calendario indicado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo, y hora universal coordinada (UTC) u hora local especificados para el calendario indicado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicializa una nueva instancia de la estructura DateTime en el año, mes, día, hora, minuto, segundo, milisegundo y hora universal coordinada (UTC) u hora local especificados.

System_CAPS_pubmethodDateTime(Int64)

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

System_CAPS_pubmethodDateTime(Int64, DateTimeKind)

Inicializa una nueva instancia de la estructura DateTime en el número de pasos y hora universal coordinada (UTC) u hora local especificados.

NombreDescripción
System_CAPS_pubpropertyDate

Obtiene el componente correspondiente a la fecha de esta instancia.

System_CAPS_pubpropertyDay

Obtiene el día del mes representado por esta instancia.

System_CAPS_pubpropertyDayOfWeek

Obtiene el día de la semana representado por esta instancia.

System_CAPS_pubpropertyDayOfYear

Obtiene el día del año representado por esta instancia.

System_CAPS_pubpropertyHour

Obtiene el componente correspondiente a la hora de la fecha representada por esta instancia.

System_CAPS_pubpropertyKind

Obtiene un valor que indica si la hora representada por esta instancia está basada en la hora local, en la hora universal coordinada (UTC), o en ninguna de ellas.

System_CAPS_pubpropertyMillisecond

Obtiene el componente correspondiente a los milisegundos de la fecha representada por esta instancia.

System_CAPS_pubpropertyMinute

Obtiene el componente correspondiente a los minutos de la fecha representada por esta instancia.

System_CAPS_pubpropertyMonth

Obtiene el componente correspondiente al mes de la fecha representada por esta instancia.

System_CAPS_pubpropertySystem_CAPS_staticNow

Obtiene un objeto DateTime que se establece en la fecha y hora actual de este equipo, expresada como hora local.

System_CAPS_pubpropertySecond

Obtiene el componente correspondiente a los segundos de la fecha representada por esta instancia.

System_CAPS_pubpropertyTicks

Obtiene el número de pasos que representan la fecha y hora de esta instancia.

System_CAPS_pubpropertyTimeOfDay

Obtiene la hora del día para esta instancia.

System_CAPS_pubpropertySystem_CAPS_staticToday

Obtiene la fecha actual.

System_CAPS_pubpropertySystem_CAPS_staticUtcNow

Obtiene un objeto DateTime que se establece en la fecha y hora actual del equipo, expresada como hora universal coordinada (UTC).

System_CAPS_pubpropertyYear

Obtiene el componente correspondiente al año de la fecha representada por esta instancia.

NombreDescripción
System_CAPS_pubmethodAdd(TimeSpan)

Devuelve un nuevo objeto DateTime que suma el valor del objeto TimeSpan especificado al valor de esta instancia.

System_CAPS_pubmethodAddDays(Double)

Devuelve un nuevo objeto DateTime que suma el número especificado de días al valor de esta instancia.

System_CAPS_pubmethodAddHours(Double)

Devuelve un nuevo objeto DateTime que suma el número especificado de horas al valor de esta instancia.

System_CAPS_pubmethodAddMilliseconds(Double)

Devuelve un nuevo objeto DateTime que suma el número especificado de milisegundos al valor de esta instancia.

System_CAPS_pubmethodAddMinutes(Double)

Devuelve un nuevo objeto DateTime que suma el número especificado de minutos al valor de esta instancia.

System_CAPS_pubmethodAddMonths(Int32)

Devuelve un nuevo objeto DateTime que suma el número especificado de meses al valor de esta instancia.

System_CAPS_pubmethodAddSeconds(Double)

Devuelve un nuevo objeto DateTime que suma el número especificado de segundos al valor de esta instancia.

System_CAPS_pubmethodAddTicks(Int64)

Devuelve un nuevo objeto DateTime que suma el número especificado de pasos al valor de esta instancia.

System_CAPS_pubmethodAddYears(Int32)

Devuelve un nuevo objeto DateTime que suma el número especificado de años al valor de esta instancia.

System_CAPS_pubmethodSystem_CAPS_staticCompare(DateTime, DateTime)

Compara dos instancias de DateTime y devuelve un entero que indica si la primera instancia es anterior, igual o posterior a la segunda instancia.

System_CAPS_pubmethodCompareTo(DateTime)

Compara el valor de esta instancia con un valor de DateTime especificado y devuelve un entero que indica si esta instancia es anterior, igual o posterior al valor de DateTime especificado.

System_CAPS_pubmethodCompareTo(Object)

Compara el valor de esta instancia con un objeto especificado que contiene un valor de DateTime especificado y devuelve un entero que indica si esta instancia es anterior, igual o posterior al valor de DateTime especificado.

System_CAPS_pubmethodSystem_CAPS_staticDaysInMonth(Int32, Int32)

Devuelve el número de días del mes y año especificados.

System_CAPS_pubmethodEquals(DateTime)

Devuelve un valor que indica si el valor de esta instancia equivale al valor de la instancia de DateTime especificada.

System_CAPS_pubmethodSystem_CAPS_staticEquals(DateTime, DateTime)

Devuelve un valor que indica si dos instancias de DateTime tienen el mismo valor de fecha y hora.

System_CAPS_pubmethodEquals(Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFromBinary(Int64)

Deserializa un valor binario de 64 bits y vuelve a crear un objeto DateTime serializado original.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTime(Int64)

Convierte la hora de archivo de Windows especificada en una hora local equivalente.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTimeUtc(Int64)

Convierte la hora de archivo de Windows especificada en una hora UTC equivalente.

System_CAPS_pubmethodSystem_CAPS_staticFromOADate(Double)

Devuelve un DateTime que equivale a la fecha de automatización OLE especificada.

System_CAPS_pubmethodGetDateTimeFormats()

Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por los especificadores de formato de fecha y hora estándar.

System_CAPS_pubmethodGetDateTimeFormats(Char)

Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por el especificador de formato de fecha y hora estándar indicado.

System_CAPS_pubmethodGetDateTimeFormats(Char, IFormatProvider)

Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por el especificador de formato de fecha y hora estándar y la información de formato específica de la referencia cultural especificados.

System_CAPS_pubmethodGetDateTimeFormats(IFormatProvider)

Convierte el valor de esta instancia en todas las representaciones de cadena admitidas por los especificadores de formato de fecha y hora estándar y la información de formato específica de la referencia cultural especificada.

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Invalida ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

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

System_CAPS_pubmethodGetTypeCode()

Devuelve el TypeCode para el tipo de valor DateTime.

System_CAPS_pubmethodIsDaylightSavingTime()

Indica si esta instancia de DateTime está dentro del intervalo del horario de verano de la zona horaria actual.

System_CAPS_pubmethodSystem_CAPS_staticIsLeapYear(Int32)

Devuelve una indicación en la que se precisa si el año especificado es bisiesto.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Convierte la representación de cadena para una fecha y hora en su DateTime equivalente, usando la información de formato específica de la referencia cultural especificada.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider, DateTimeStyles)

Convierte la representación de cadena de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y el estilo de formato especificados.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la información de formato específica de la referencia cultural y el formato que se hayan especificado. El formato de la representación de cadena debe coincidir exactamente con el formato especificado.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider, DateTimeStyles)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado; de lo contrario, se produce una excepción.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String[], IFormatProvider, DateTimeStyles)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la matriz de formatos, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con, al menos, uno de los formatos especificados; de lo contrario se produce una excepción.

System_CAPS_pubmethodSystem_CAPS_staticSpecifyKind(DateTime, DateTimeKind)

Crea un nuevo objeto DateTime que tiene el mismo número de pasos que el objeto DateTime especificado, pero en hora local, en hora universal coordinada (UTC) o en ninguna de ellas, según indique el valor de DateTimeKind especificado.

System_CAPS_pubmethodSubtract(DateTime)

Resta la fecha y hora especificadas de esta instancia.

System_CAPS_pubmethodSubtract(TimeSpan)

Resta la duración especificada de esta instancia.

System_CAPS_pubmethodToBinary()

Serializa el objeto DateTime actual a un valor binario de 64 bits que se puede usar después para volver a crear el objeto DateTime.

System_CAPS_pubmethodToFileTime()

Convierte el valor del objeto DateTime actual en una hora de archivo de Windows.

System_CAPS_pubmethodToFileTimeUtc()

Convierte el valor del objeto DateTime actual en una hora de archivo de Windows.

System_CAPS_pubmethodToLocalTime()

Convierte el valor del objeto DateTime actual a la hora local.

System_CAPS_pubmethodToLongDateString()

Convierte el valor del objeto DateTime actual en su representación de cadena de fecha larga equivalente.

System_CAPS_pubmethodToLongTimeString()

Convierte el valor del objeto DateTime actual en su representación de cadena de hora larga equivalente.

System_CAPS_pubmethodToOADate()

Convierte el valor de esta instancia en la fecha de automatización OLE equivalente.

System_CAPS_pubmethodToShortDateString()

Convierte el valor del objeto DateTime actual en su representación de cadena de fecha corta equivalente.

System_CAPS_pubmethodToShortTimeString()

Convierte el valor del objeto DateTime actual en su representación de cadena de hora corta equivalente.

System_CAPS_pubmethodToString()

Convierte el valor del objeto DateTime actual en su representación de cadena equivalente usando las convenciones de formato de la referencia cultural actual.(Invalida ValueType.ToString()).

System_CAPS_pubmethodToString(IFormatProvider)

Convierte el valor del objeto DateTime actual en su representación de cadena equivalente usando la información de formato específica de la referencia cultural especificada.

System_CAPS_pubmethodToString(String)

Convierte el valor del objeto DateTime actual en su representación de cadena equivalente usando el formato especificado y las convenciones de formato de la referencia cultural actual.

System_CAPS_pubmethodToString(String, IFormatProvider)

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

System_CAPS_pubmethodToUniversalTime()

Convierte el valor del objeto DateTime actual a la hora universal coordinada (UTC).

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, DateTime)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente y devuelve un valor que indica si la conversión se realizó correctamente.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Convierte la representación de cadena especificada de una fecha y hora en su equivalente DateTime usando la información de formato de la referencia cultural y el estilo de formato especificados, y devuelve un valor que indica si la conversión tuvo éxito.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando el formato, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con el formato especificado. El método devuelve un valor que indica si la conversión se realizó correctamente.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Convierte la representación de cadena especificada de una fecha y hora en el objeto DateTime equivalente, usando la matriz de formatos, la información de formato específica de la referencia cultural y el estilo especificados. El formato de la representación de cadena debe coincidir exactamente con al menos uno de los formatos especificados. El método devuelve un valor que indica si la conversión se realizó correctamente.

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Representa el mayor valor posible de DateTime. Este campo es de solo lectura.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Representa el menor valor posible de DateTime. Este campo es de solo lectura.

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticAddition(DateTime, TimeSpan)

Agrega un intervalo de tiempo especificado a una fecha y hora especificadas, generando una fecha y hora nuevas.

System_CAPS_puboperatorSystem_CAPS_staticEquality(DateTime, DateTime)

Determina si dos instancias especificadas de DateTime son iguales.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(DateTime, DateTime)

Determina si un DateTime especificado es posterior a otro DateTime especificado.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(DateTime, DateTime)

Determina si un DateTime especificado representa una fecha y hora que es el igual o posterior a otro DateTime especificado.

System_CAPS_puboperatorSystem_CAPS_staticInequality(DateTime, DateTime)

Determina si dos instancias especificadas de DateTime no son iguales.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(DateTime, DateTime)

Determina si un DateTime especificado es anterior a otro DateTime especificado.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(DateTime, DateTime)

Determina si un DateTime especificado representa una fecha y hora que es el igual o anterior a otro DateTime especificado.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, DateTime)

Resta una fecha y hora especificadas de otra fecha y hora especificadas y devuelve un intervalo de tiempo.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, TimeSpan)

Resta un intervalo de tiempo especificado de un valor de fecha y hora especificado y devuelve un nuevo valor de fecha y hora.

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Devuelve el objeto DateTime actual.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Convierte el objeto DateTime actual en un objeto de un tipo especificado.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto DateTime actual.

System_CAPS_noteNota

Para ver el código fuente de .NET Framework para este tipo, consulte el Reference Source. Puede examinar el código fuente en línea, descargue la referencia para verla sin conexión y recorrer (incluidas las revisiones y actualizaciones) durante la depuración; see instructions.

El DateTime tipo de valor representa las fechas y el tiempo de espera con valores están comprendidos entre 00:00:00 (medianoche), 1 de enero de 0001 D.c. (Era común) a 11:59:59 P.M. del 31 de diciembre de 9999 D.C. (E.C.) en el calendario gregoriano.

Valores de tiempo se miden en unidades de 100 nanosegundos denominadas pasos, y una fecha concreta es el número de pasos transcurridos desde la medianoche de 12:00 del 1 de enero de 0001 D.C. (E.C.) en el GregorianCalendar calendario (excepto los pasos que se agregarían por segundos intercalares). Por ejemplo, un valor en pasos de 31241376000000000L representa la fecha, el viernes 01 de enero de 0100 a las 12:00:00 de la noche. Un DateTime valor se expresa siempre en el contexto de explícita o calendario predeterminado.

System_CAPS_noteNota

Si está trabajando con un valor de pasos que desea convertir en algún otro intervalo de hora, como minutos o segundos, debería utilizar el TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, o TimeSpan.TicksPerMillisecond constante para realizar la conversión. Por ejemplo agregar el número de segundos representado por un número especificado de pasos a la Second componente de un DateTime valor, puede utilizar la expresión dateValue.Second + nTicks/Timespan.TicksPerSecond.

En esta sección:

Instancias de un objeto de fecha y hora
Valores de DateTime y sus representaciones de cadena
Convertir cadenas en valores de fecha y hora
Consideraciones de versión
Valores de fecha y hora
Operaciones de fecha y hora
Resolución de fecha y hora
Frente a DateTime TimeSpan
Valores de fecha y hora y calendarios
Conservar valores de fecha y hora
Consideraciones de interoperabilidad COM

Puede crear un nuevo DateTime valor en cualquiera de las maneras siguientes:

  • Al llamar a cualquiera de las sobrecargas de los DateTime constructor que le permiten especificar elementos concretos del valor de fecha y hora (como el año, mes y día o el número de pasos). La instrucción siguiente muestra una llamada a uno de los DateTime constructores para crear una fecha con un año específico mes, día, hora, minuto y segundo.

    DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
    
  • Mediante cualquier sintaxis específica del compilador para declarar los valores de fecha y hora. Por ejemplo, la siguiente instrucción de Visual Basic inicializa un nuevo DateTime valor.

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
  • Asignando el DateTime un valor de fecha y hora devuelto por una propiedad o método del objeto. En el ejemplo siguiente se asigna la actual fecha y hora, la fecha actual de la hora Universal coordinada (UTC) y hora y la fecha actual a tres nuevas DateTime variables.

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
  • Mediante el análisis de la representación de cadena de un valor de fecha y hora. El Parse, ParseExact, TryParse, y TryParseExact todos los métodos de convierten una cadena en su equivalente valor fecha y hora. En el ejemplo siguiente se usa el Parse método para analizar una cadena y convertirla a una DateTime valor.

    string dateString = "5/1/2008 8:30:52 AM";
    DateTime date1 = DateTime.Parse(dateString, 
                              System.Globalization.CultureInfo.InvariantCulture); 
    

    Tenga en cuenta que la TryParse y TryParseExact métodos indican si una cadena determinada contiene una representación válida de un DateTime valor además de realizar la conversión.

  • Al llamar a la DateTime el constructor predeterminado implícito de estructura. (Para obtener más información sobre el constructor predeterminado implícito de un tipo de valor, vea Tipos de valor (Referencia de C#).) Un equivalente aproximado, para los compiladores que lo admiten, es declarar un DateTime valor sin asignarle explícitamente una fecha y hora. En el ejemplo siguiente se muestra una llamada a la DateTime constructor predeterminado implícito en C# y Visual Basic, así como un DateTime declaración de variable sin asignación en Visual Basic.

    DateTime dat1 = new DateTime();
    // The following method call displays 1/1/0001 12:00:00 AM.
    Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
    // The following method call displays True.
    Console.WriteLine(dat1.Equals(DateTime.MinValue));
    

Internamente, todos DateTime valores se representan como el número de pasos (el número de intervalos de 100 nanosegundos) transcurridos desde la medianoche de 12:00:00 del 1 de enero de 0001. Los verdaderos DateTime valor es independiente de la forma en que dicho valor aparece cuando se muestra en un elemento de la interfaz de usuario o cuando se escribe en un archivo. La apariencia de un DateTime valor es el resultado de una operación de formato. Formato es el proceso de convertir un valor en su representación de cadena.

Dado que la apariencia de los valores de fecha y hora depende de factores tales como la referencia cultural, normas internacionales, requisitos de la aplicación y preferencias personales, el DateTime estructura ofrece mucha flexibilidad para dar formato a valores de fecha y hora a través de las sobrecargas de su ToString método. El valor predeterminado DateTime.ToString() método devuelve la representación de cadena de un valor de fecha y hora utilizando la fecha corta y el patrón de hora larga de la referencia cultural actual. En el ejemplo siguiente se utiliza el valor predeterminado DateTime.ToString() método para mostrar la fecha y hora utilizando la fecha corta y el patrón de hora larga para en-US de la referencia cultural, la referencia cultural actual en el equipo donde se ejecutó el ejemplo.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM

El DateTime.ToString(IFormatProvider) método devuelve la representación de cadena de un valor de fecha y hora utilizando la fecha corta y el modelo horario largo de una referencia cultural concreta. En el ejemplo siguiente se usa el DateTime.ToString(IFormatProvider) método para mostrar la fecha y hora utilizando la fecha corta y el modelo horario largo para la referencia cultural fr-FR.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00

El DateTime.ToString(String) método devuelve la representación de cadena de fecha y hora en un formato definido por un especificador de formato estándar o personalizado, utilizando las convenciones de formato de la referencia cultural actual. En el ejemplo siguiente se usa el DateTime.ToString(String) método para mostrar la fecha completa y el patrón de tiempo para en-US de la referencia cultural, la referencia cultural actual en el equipo donde se ejecutó el ejemplo.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM

El DateTime.ToString(String, IFormatProvider) método devuelve la representación de cadena de fecha y hora en un formato definido por un especificador de formato concreto utilizando las convenciones de formato de una referencia cultural concreta. En el ejemplo siguiente se usa el DateTime.ToString(String, IFormatProvider) método para mostrar el completo modelo fecha y hora para la referencia cultural fr-FR.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00

Para obtener más información acerca del formato DateTime valores, consulte Cadenas con formato de fecha y hora estándar y Cadenas con formato de fecha y hora personalizado.

Análisis implica convertir la representación de cadena de una fecha y hora para una DateTime valor. Normalmente, las cadenas de fecha y hora tienen dos usos diferentes de aplicaciones:

  • Representan una fecha y hora que puede tomar diversas formas y que reflejan las convenciones de la referencia cultural actual o una referencia cultural concreta. Por ejemplo, una aplicación puede permitir que a un usuario cuya referencia cultural actual es en-US, escriba un valor de fecha como "15/12/2013" o "15 de diciembre de 2013", y permitir que a un usuario cuya referencia cultural actual es en-GB, escriba un valor de fecha como "15/12/2013" o "15 de diciembre de 2013".

  • Representan una fecha y hora en un formato predefinido. Por ejemplo, una aplicación puede serializar una fecha como "20130103" independientemente de la referencia cultural en la que se ejecuta la aplicación o puede requerir que se introduce una fecha en formato de fecha corta de la referencia cultural actual.

Puede usar el Parse o TryParse método para convertir una cadena que puede reflejar uno de los formatos de fecha y hora comunes de una referencia cultural para un DateTime valor. En el ejemplo siguiente se muestra cómo se puede utilizar TryParse para convertir las cadenas de fecha en un número de diferentes formatos específicos de la referencia cultural en un DateTime valor. Cambia la referencia cultural actual a inglés (Reino Unido) y llama el GetDateTimeFormats() método para generar una matriz de cadenas de fecha y hora. A continuación, pasa cada elemento de la matriz el TryParse método. El resultado del ejemplo muestra que el método de análisis fue capaz de convertir correctamente cada una de las cadenas de hora y fecha específica de la referencia cultural.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

      DateTime date1 = new DateTime(2013, 6, 1, 12, 32, 30);
      List<string> badFormats = new List<String>();

      Console.WriteLine("{0,-37} {1,-19}\n", "Date String", "Date");
      foreach (var dateString in date1.GetDateTimeFormats()) {
         DateTime parsedDate;
         if (DateTime.TryParse(dateString, out parsedDate))
            Console.WriteLine("{0,-37} {1,-19}", dateString, DateTime.Parse(dateString));
         else
            badFormats.Add(dateString);
      } 

      // Display strings that could not be parsed.
      if (badFormats.Count > 0) {
         Console.WriteLine("\nStrings that could not be parsed: ");
         foreach (var badFormat in badFormats)
            Console.WriteLine("   {0}", badFormat);         
      }
   }
}
// The example displays the following output:
//       Date String                           Date               
//       
//       01/06/2013                            01/06/2013 00:00:00
//       01/06/13                              01/06/2013 00:00:00
//       1/6/13                                01/06/2013 00:00:00
//       1.6.13                                01/06/2013 00:00:00
//       2013-06-01                            01/06/2013 00:00:00
//       01 June 2013                          01/06/2013 00:00:00
//       1 June 2013                           01/06/2013 00:00:00
//       01 June 2013 12:32                    01/06/2013 12:32:00
//       01 June 2013 12:32                    01/06/2013 12:32:00
//       01 June 2013 12:32 PM                 01/06/2013 12:32:00
//       01 June 2013 12:32 PM                 01/06/2013 12:32:00
//       1 June 2013 12:32                     01/06/2013 12:32:00
//       1 June 2013 12:32                     01/06/2013 12:32:00
//       1 June 2013 12:32 PM                  01/06/2013 12:32:00
//       1 June 2013 12:32 PM                  01/06/2013 12:32:00
//       01 June 2013 12:32:30                 01/06/2013 12:32:30
//       01 June 2013 12:32:30                 01/06/2013 12:32:30
//       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
//       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
//       1 June 2013 12:32:30                  01/06/2013 12:32:30
//       1 June 2013 12:32:30                  01/06/2013 12:32:30
//       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
//       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
//       01/06/2013 12:32                      01/06/2013 12:32:00
//       01/06/2013 12:32                      01/06/2013 12:32:00
//       01/06/2013 12:32 PM                   01/06/2013 12:32:00
//       01/06/2013 12:32 PM                   01/06/2013 12:32:00
//       01/06/13 12:32                        01/06/2013 12:32:00
//       01/06/13 12:32                        01/06/2013 12:32:00
//       01/06/13 12:32 PM                     01/06/2013 12:32:00
//       01/06/13 12:32 PM                     01/06/2013 12:32:00
//       1/6/13 12:32                          01/06/2013 12:32:00
//       1/6/13 12:32                          01/06/2013 12:32:00
//       1/6/13 12:32 PM                       01/06/2013 12:32:00
//       1/6/13 12:32 PM                       01/06/2013 12:32:00
//       1.6.13 12:32                          01/06/2013 12:32:00
//       1.6.13 12:32                          01/06/2013 12:32:00
//       1.6.13 12:32 PM                       01/06/2013 12:32:00
//       1.6.13 12:32 PM                       01/06/2013 12:32:00
//       2013-06-01 12:32                      01/06/2013 12:32:00
//       2013-06-01 12:32                      01/06/2013 12:32:00
//       2013-06-01 12:32 PM                   01/06/2013 12:32:00
//       2013-06-01 12:32 PM                   01/06/2013 12:32:00
//       01/06/2013 12:32:30                   01/06/2013 12:32:30
//       01/06/2013 12:32:30                   01/06/2013 12:32:30
//       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
//       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
//       01/06/13 12:32:30                     01/06/2013 12:32:30
//       01/06/13 12:32:30                     01/06/2013 12:32:30
//       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
//       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
//       1/6/13 12:32:30                       01/06/2013 12:32:30
//       1/6/13 12:32:30                       01/06/2013 12:32:30
//       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
//       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
//       1.6.13 12:32:30                       01/06/2013 12:32:30
//       1.6.13 12:32:30                       01/06/2013 12:32:30
//       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
//       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
//       2013-06-01 12:32:30                   01/06/2013 12:32:30
//       2013-06-01 12:32:30                   01/06/2013 12:32:30
//       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
//       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
//       01 June                               01/06/2013 00:00:00
//       01 June                               01/06/2013 00:00:00
//       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
//       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
//       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
//       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
//       2013-06-01T12:32:30                   01/06/2013 12:32:30
//       12:32                                 22/04/2013 12:32:00
//       12:32                                 22/04/2013 12:32:00
//       12:32 PM                              22/04/2013 12:32:00
//       12:32 PM                              22/04/2013 12:32:00
//       12:32:30                              22/04/2013 12:32:30
//       12:32:30                              22/04/2013 12:32:30
//       12:32:30 PM                           22/04/2013 12:32:30
//       12:32:30 PM                           22/04/2013 12:32:30
//       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
//       01 June 2013 19:32:30                 01/06/2013 19:32:30
//       01 June 2013 19:32:30                 01/06/2013 19:32:30
//       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
//       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
//       1 June 2013 19:32:30                  01/06/2013 19:32:30
//       1 June 2013 19:32:30                  01/06/2013 19:32:30
//       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
//       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
//       June 2013                             01/06/2013 00:00:00
//       June 2013                             01/06/2013 00:00:00

Puede usar el TryParse y TryParseExact métodos para convertir una cadena de fecha y hora en que debe coincidir con un formato determinado o formatos a una DateTime valor. Especifique el formato requerido o los formatos como parámetro para el análisis methodby utilizando uno o más o cadenas de formato de fecha y hora. En el ejemplo siguiente se usa el TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método para convertir cadenas que deben estar en un formato de "AAAAMMDD" o en un formato "HHmmss" DateTime valores.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats = { "yyyyMMdd", "HHmmss" };
      string[] dateStrings = { "20130816", "20131608", "  20130816   ", 
                               "115216", "521116", "  115216  " };
      DateTime parsedDate;

      foreach (var dateString in dateStrings) {
         if (DateTime.TryParseExact(dateString, formats, null, 
                                    DateTimeStyles.AllowWhiteSpaces |
                                    DateTimeStyles.AdjustToUniversal,
                                    out parsedDate))
            Console.WriteLine("{0} --> {1:g}", dateString, parsedDate);
         else
            Console.WriteLine("Cannot convert {0}", dateString);
      }
   }
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM

El Parse y ParseExact métodos producen una excepción si la cadena se convierta en un DateTime no se puede analizar el valor. El TryParse y TryParseExact métodos devuelven un Boolean valor que indica si la conversión se realizó correctamente o no. Dado que la operación de análisis para las cadenas de fecha y hora, especialmente si las cadenas especificadas por usuarios, tiende a tener un alto índice de fallas, y dado que el control de excepciones es caro, debería usar la TryParse o TryParseExact métodos en escenarios donde el rendimiento es importante o conversiones están sujetos a una alta tasa de error.

Para obtener más información sobre el análisis de valores de fecha y hora, consulte Analizar cadenas de fecha y hora en .NET Framework.

Antes de .NET Framework versión 2.0, la DateTime estructura contiene un campo de 64 bits formado por un campo de 2 bits no utilizado concatenado con una privada Ticks campo, que es un campo de 62 bits sin signo que contiene el número de pasos que representan la fecha y hora. El valor de la Ticks campo puede obtenerse con el Ticks propiedad.

A partir de .NET Framework 2.0, el DateTime estructura contiene un campo de 64 bits formado por un campo Kind privado concatenado con el campo Ticks. El campo Kind es un campo de 2 bits que indica si la DateTime estructura representa una hora local, una hora Universal coordinada (UTC) o la hora en una zona horaria no especificada. El campo Kind se usa cuando se realizan conversiones de horas entre zonas horarias, pero no para realizar operaciones aritméticas o comparaciones de tiempo. El valor del campo Kind se puede obtener con el Kind propiedad.

System_CAPS_noteNota

Una alternativa a la DateTime estructura para trabajar con valores de fecha y hora en zonas horarias en particular es el DateTimeOffset estructura. El DateTimeOffset estructura almacena información de fecha y hora en privado DateTime campo y el número de minutos que esa fecha y hora difiere de la hora UTC en privado Int16 campo. Esto posibilita una DateTimeOffset valor para reflejar la hora en una zona horaria determinada, mientras que un DateTime valor puede reflejar inequívocamente solo la hora UTC y la zona horaria local. Para obtener información sobre cuándo utilizar el DateTime estructura o el DateTimeOffset estructura al trabajar con valores de fecha y hora, vea Elegir entre DateTime, DateTimeOffset, TimeSpan y TimeZoneInfo.

Descripciones de los valores de tiempo en el DateTime tipo se suelen expresar utilizando el estándar de hora Universal coordinada (UTC), que es el nombre reconocido internacionalmente para la hora del meridiano de Greenwich (GMT). Hora Universal coordinada es el tiempo que se mide en la longitud cero grados, el punto de origen de UTC. Horario de verano no es aplicable a la hora UTC.

Es la hora local en relación con una zona horaria determinada. Una zona horaria se asocia con un desplazamiento de zona horaria, que es el desplazamiento de la zona horaria, medido en horas desde el punto de origen de UTC. Además, la hora local, opcionalmente, se ve afectada por el horario de verano, que agrega o resta una hora a la duración de un día. Por consiguiente, la hora local se calcula agregando el desplazamiento de zona horaria UTC y ajuste del horario de verano si es necesario. El desplazamiento de zona horaria en el punto de origen de UTC es cero.

Hora UTC es adecuada para los cálculos, las comparaciones, almacenar fechas y horas en los archivos. Hora local es apropiada para su presentación en interfaces de usuario de aplicaciones de escritorio. Tenga en cuenta la zona horaria aplicaciones (por ejemplo, muchas aplicaciones Web) también necesitan trabajar con un número de otras zonas horarias.

Si el Kind propiedad de un DateTime objeto es DateTimeKind.Unspecified, no se especifica si la hora representada es la hora local, hora UTC o una hora de otra zona horaria.

Un cálculo utilizando un DateTime estructura, como Add o Subtract, no modifica el valor de la estructura. En su lugar, el cálculo devuelve una nueva DateTime estructura cuyo valor es el resultado del cálculo.

Las operaciones de conversión entre zonas horarias (por ejemplo, entre la hora UTC y la hora local, o entre una zona horaria y otra) tienen horario de verano en cuenta, pero las operaciones aritméticas y de comparación no lo hacen.

El DateTime propia estructura ofrece compatibilidad limitada para la conversión de una zona horaria a otra. Puede usar el ToLocalTime método para convertir la hora UTC en hora local, o bien puede usar el ToUniversalTime método para convertir de hora local a UTC. Sin embargo, un conjunto completo de métodos de conversión de zona horaria está disponible en la TimeZoneInfo clase. Con estos métodos, puede convertir la hora en cualquiera de las zonas horarias del mundo en la hora de cualquier otra zona horaria.

Cálculos y las comparaciones de DateTime objetos son significativos solo si los objetos representan horas de la misma zona horaria. Puede usar un TimeZoneInfo objeto para representar un DateTime hora del valor de la zona, aunque los dos están acoplados. (Eso es, un DateTime objeto no tiene una propiedad que devuelve un objeto que representa la zona de horaria de ese valor de fecha y hora distinto del Kind propiedad.) Por este motivo, en una aplicación que tenga en cuenta la zona horaria, debe basarse en algún mecanismo externo para determinar la zona horaria en la que un DateTime se creó el objeto. Por ejemplo, podría utilizar una estructura que contiene tanto el DateTime valor y TimeZoneInfo objeto que representa la DateTime zona horaria del valor. Para obtener más información sobre el uso de hora UTC en cálculos y comparaciones con DateTime valores, consulte Efectuar operaciones aritméticas con fechas y horas.

Cada DateTime miembro utiliza implícitamente el calendario gregoriano para realizar sus operaciones, excepto los constructores que especifican un calendario y los métodos con un parámetro derivan de IFormatProvider, como System.Globalization.DateTimeFormatInfo, que indican implícitamente un calendario.

Las operaciones de los miembros de la DateTime tipo tomar en detalles de cuenta, como los años bisiestos y el número de días del mes.

Dos otras operaciones comunes con DateTime valores implican la conversión a o desde su representación de cadena de un valor de fecha y hora. El proceso de convertir un DateTime valor en su representación de cadena es una operación de formato; para obtener más información acerca del formato, consulte DateTime valores y sus representaciones de cadena. El proceso de convertir la representación de cadena de una fecha y hora para una DateTime valor es una operación de análisis; para obtener más información acerca del análisis, consulte convertir cadenas en valores DateTime.

System_CAPS_noteNota

Como alternativa a la realización de fecha y hora aritmética en DateTime valores para medir el tiempo transcurrido, puede usar el Stopwatch clase.

El Ticks propiedad expresa los valores de fecha y hora en unidades de una diez millonésima de segundo y el Millisecond propiedad devuelve las milésimas de segundo de un valor de fecha y hora. Sin embargo, si está utilizando llamadas repetidas a la DateTime.Now propiedad para medir el tiempo transcurrido y que está relacionada con los intervalos de tiempo de pequeñas con menos de 100 milisegundos, debe tener en cuenta que los valores devueltos por la DateTime.Now propiedad dependen del reloj del sistema, que en los sistemas Windows 7 y Windows 8 tiene una resolución de aproximadamente 15 milisegundos.

En el ejemplo siguiente se muestra la dependencia de los valores de hora y fecha actual de la resolución del reloj del sistema. En el ejemplo, 20 veces que se repite un bucle exterior y un bucle interno sirve para retrasar el bucle exterior. Si el valor del contador de bucle exterior es 10, una llamada a la Thread.Sleep método introduce un retraso de cinco milisegundos. Como se muestra en el resultado del ejemplo, devuelve el número de milisegundos en el DateTime.Now.Milliseconds cambia la propiedad sólo después de llamar a Thread.Sleep.

using System;
using System.Threading;

public class Example
{
   public static void Main()
   {
      String output = "";
      for (int ctr = 0; ctr <= 20; ctr++) {
         output += String.Format("{0}\n", DateTime.Now.Millisecond);
         // Introduce a delay loop.
         for (int delay = 0; delay <= 1000; delay++)
         {}

         if (ctr == 10) {
            output += "Thread.Sleep called...\n";
            Thread.Sleep(5);
         }
      }
      Console.WriteLine(output);
   }
}
// The example displays the following output:
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       Thread.Sleep called...
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143

El DateTime y TimeSpan tipos de valor difieren en que un DateTime representa un instante de tiempo, mientras que un TimeSpan representa un intervalo de tiempo. Esto significa, por ejemplo, que se puede restar una instancia de DateTime de otra para obtener un TimeSpan objeto que representa el intervalo de tiempo entre ellos. O puede agregar un positivo TimeSpan actual DateTime para obtener un DateTime valor que representa una fecha futura.

Puede agregar o restar un intervalo de tiempo de un DateTime objeto. Intervalos de tiempo puede ser positivo o negativo, se puede expresar en unidades como pasos o segundos o puede expresarse como un TimeSpan objeto.

La biblioteca de clases de .NET Framework incluye varias clases de calendario, que se derivan de la Calendar clase. Son estos:

Cada referencia cultural usa un calendario predeterminado definido por su de sólo lectura CultureInfo.Calendar propiedad y es compatible con uno o varios calendarios definidos por su de sólo lectura CultureInfo.OptionalCalendars propiedad. El calendario utilizado actualmente por un determinado CultureInfo objeto se define por su DateTimeFormatInfo.Calendar propiedad; debe ser uno de los calendarios que se encuentra en la CultureInfo.OptionalCalendars matriz.

Calendario de la referencia cultural actual se utiliza en todas las operaciones de formato para la referencia cultural. Por ejemplo, el calendario predeterminado de la referencia cultural persa (irán) es la um-al-Qura calendario, que se representa mediante la UmAlQuraCalendar clase. Cuando un CultureInfo objeto que representa la referencia cultural persa (irán) se utiliza en una fecha y hora de formato de operación, la um-al-Qura calendario se utiliza de forma predeterminada y el calendario gregoriano se usa únicamente si la referencia cultural DateTimeFormatInfo.Calendar se cambia la propiedad, como se muestra en el ejemplo siguiente.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = new DateTime(2016, 5, 28);

      Console.WriteLine(value.ToString(faIR));

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
// 08/03/1395 12:00:00 ?.?
// 28/05/2016 12:00:00 ?.?

Calendario de la referencia cultural actual también se utiliza en todas las operaciones de análisis para la referencia cultural, como se muestra en el ejemplo siguiente.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = DateTime.Parse("08/03/1395", faIR);
      Console.WriteLine(value.ToString(faIR));

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
//       08/03/1395 12:00:00 ?.?
//       28/05/2016 12:00:00 ?.?

También puede crear una instancia un DateTime valor mediante el uso de los elementos de fecha y hora (como el número de year, month y day) de un calendario específico mediante una llamada a un constructor DateTime que incluye un calendar parámetro y se le pasa un Calendar objeto que representa dicho calendario. En el ejemplo siguiente se hace mediante el uso de los elementos de fecha y hora desde el UmAlQuraCalendar calendario.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var dat = new DateTime(1395, 8, 18, faIR.DateTimeFormat.Calendar);
      Console.WriteLine("Umm-al-Qura date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Gregorian date:   {0:d}", dat);
   }
}
// The example displays the following output:
//       Umm-al-Qura date: 18/08/1395
//       Gregorian date:   11/8/2016

DateTime los constructores que no incluyen un calendar parámetro, se supone que los elementos de fecha y hora se expresan como unidades en el calendario gregoriano.

Todos los demás DateTime Propiedades y métodos utilizan el calendario gregoriano. Por ejemplo, el DateTime.Year propiedad devuelve el año en el calendario gregoriano y el DateTime.IsLeapYear(Int32) método supone que la year parámetro es un año en el calendario gregoriano. Cada DateTime miembro que usa el calendario gregoriano tiene un miembro correspondiente de la Calendar clase que utiliza un calendario específico. Por ejemplo, el Calendar.GetYear método devuelve el año de un calendario específico y el Calendar.IsLeapYear método interpreta la year parámetro como un número de años de un calendario específico. En el ejemplo siguiente se utiliza tanto el DateTime y los miembros correspondientes de la UmAlQuraCalendar clase.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var cal = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, cal);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Year: {0}", cal.GetYear(dat));
      Console.WriteLine("Leap year: {0}\n", 
                        cal.IsLeapYear(cal.GetYear(dat)));

      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Year: {0}", dat.Year);
      Console.WriteLine("Leap year: {0}", DateTime.IsLeapYear(dat.Year));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Year: 1395
//       Leap year: True
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Year: 2016
//       Leap year: True

Aunque el DateTime estructura incluye DayOfWeek propiedad que devuelve el día de la semana en el calendario gregoriano, no incluye un miembro que permite recuperar el número de semana del año. Para recuperar la semana del año, llame el calendario individual Calendar.GetWeekOfYear método. Esto se muestra en el ejemplo siguiente.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var umAlQura = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, umAlQura);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Day of Week: {0}", umAlQura.GetDayOfWeek(dat));
      Console.WriteLine("Week of year: {0}\n", 
                        umAlQura.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                               DayOfWeek.Sunday));

      var greg = new GregorianCalendar(); 
      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Day of Week: {0}", dat.DayOfWeek);
      Console.WriteLine("Week of year: {0}", 
                         greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                            DayOfWeek.Sunday));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Day of Week: Tuesday
//       Week of year: 34
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Day of Week: Tuesday
//       Week of year: 46

Para obtener más información sobre las fechas y calendarios, consulte Trabajar con calendarios.

Puede conservar DateTime valores de cuatro maneras:

Independientemente de la técnica que elija, debe asegurarse de que la rutina que restaura la DateTime valores no perder datos o producir una excepción. DateTime en caso de valores de ida y vuelta. Es decir, el valor original y el valor restaurado deben ser el mismo. Y si el original DateTime valor representa un instante de tiempo único, debe identificar el momento de tiempo cuando se restaura.

Restaurar correctamente DateTime valores que se almacenan como cadenas, siga estas reglas:

  • Realizar las mismas suposiciones sobre el formato específico de la referencia cultural cuando se restaura la cadena como cuándo se conserva. Para asegurarse de que una cadena se puede restaurar en un sistema cuya referencia cultural actual es diferente de la referencia cultural del sistema se ha guardado en, llame a la ToStringsobrecarga para guardar la cadena usando las convenciones de la referencia cultural invariable y llame el Parse(String, IFormatProvider, DateTimeStyles) o TryParse(String, IFormatProvider, DateTimeStyles, DateTime) sobrecarga para restaurar la cadena mediante las convenciones de la referencia cultural invariable. No utilice nunca la ToString(), Parse(String), o TryParse(String, DateTime) sobrecargas, que se utilizan las convenciones de la referencia cultural del subproceso actual.

  • Si los datos representan un único momento de tiempo, asegúrese de que representa el mismo momento en el tiempo cuando se restaura, incluso si se restaura en un sistema que utiliza una zona horaria diferente. Para ello, convierta la DateTime valor en hora Universal coordinada (UTC) antes de guardarlo. También puede serializar el valor junto con la información de zona horaria; Para obtener más información acerca de este enfoque, consulte los datos de serialización de fecha y hora y zona horaria.

El error más común que se realiza cuando se conserve DateTime valores como cadenas es depender de las convenciones de formato de la predeterminada o la referencia cultural actual. Si la referencia cultural actual es diferente al guardar y restaurar las cadenas, surgen problemas. En el ejemplo siguiente se ilustra estos problemas. Guarda las cinco fechas usando las convenciones de formato de la referencia cultural actual, que en este caso es inglés (Estados Unidos). Restaura las fechas con las convenciones de formato de la referencia cultural actual, que en este caso es inglés (Reino Unido). Dado que las convenciones de formato de las dos referencias culturales son diferentes, dos de las fechas no se puede restaurar y las fechas de tres restantes se interpretan incorrectamente. Además, si los valores originales de fecha y hora representan el único momento del tiempo, los datos restaurado veces son incorrectas porque se pierde la información de zona horaria.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\BadDates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      string output = null;

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      string[] inputValues = sr.ReadToEnd().Split( new char[] { '|' } , 
                                                  StringSplitOptions.RemoveEmptyEntries);
      sr.Close();
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var inputValue in inputValues) {
         DateTime dateValue;
         if (DateTime.TryParse(inputValue, out dateValue)) {
            Console.WriteLine("'{0}' --> {1:f}", inputValue, dateValue);
         }
         else {
            Console.WriteLine("Cannot parse '{0}'", inputValue);   
         }
      }
      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...

Para unificar DateTime valores correctamente, siga estos pasos:

  1. Si los valores representan solo momentos de tiempo, convertirse de la hora local a UTC llamando el ToUniversalTime método.

  2. Convertir las fechas en sus representaciones de cadena mediante una llamada a la ToString(String, IFormatProvider) o String.Format(IFormatProvider, String, Object[]) sobrecarga. Utilice las convenciones de formato de la referencia cultural invariable especificando CultureInfo.InvariantCulture como el provider argumento. Especificar que el valor debe ida y vuelta con el "O" o "R".

  3. Cuando se llama a la Parse(String, IFormatProvider, DateTimeStyles) o TryParse(String, IFormatProvider, DateTimeStyles, DateTime) (método).

Para restaurar conservados DateTime valores sin pérdida de datos, haga lo siguiente:

  1. Analizar los datos mediante una llamada a la ParseExact o TryParseExact sobrecarga. Especificar CultureInfo.InvariantCulture como el provider argumento y utilice el mismo formato estándar la cadena que se usa para el format argumento durante la conversión. Incluir la DateTimeStyles.RoundtripKind valor en el styles argumento.

  2. Si el DateTime valores representan el único momento del tiempo, llamada la ToLocalTime método para convertir la fecha analizada respecto a UTC a la hora local.

En el ejemplo siguiente se utiliza la referencia cultural y la cadena de formato estándar "O" para asegurarse de que DateTime valores que se guardan y restauran representan el mismo momento en el tiempo independientemente del sistema, la referencia cultural o la zona horaria de los sistemas de origen y de destino.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\Dates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      string output = null;

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) 
                   + (ctr != dates.Length - 1 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      string[] inputValues = sr.ReadToEnd().Split( new char[] { '|' } , 
                                                  StringSplitOptions.RemoveEmptyEntries);
      sr.Close();
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var inputValue in inputValues) {
         DateTime dateValue;
         if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, 
                               DateTimeStyles.RoundtripKind, out dateValue)) {
            Console.WriteLine("'{0}' --> {1:f}", 
                              inputValue, dateValue.ToLocalTime());
         }
         else {
            Console.WriteLine("Cannot parse '{0}'", inputValue);   
         }
      }
      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...

En vez de conservar un DateTime valor como una cadena, puede conservar como un Int64 valor que representa un número de pasos. En este caso, no tiene en cuenta la referencia cultural de los sistemas el DateTime se conserva y se restauran en valores.

Para conservar un DateTime valor como un entero:

  • Si la DateTime los valores representan el único momento del tiempo, convertir en hora UTC llamando el ToUniversalTime método.

  • Recuperar el número de pasos representados por la DateTime valor desde su Ticks propiedad.

Para restaurar un DateTime valor que se ha guardado como un entero:

  1. Crear instancias de un nuevo DateTime objeto pasando el Int64 valor para el DateTime(Int64) constructor.

  2. Si el DateTime valor representa un único momento en el tiempo, convertir a la hora UTC a la hora local mediante una llamada a la ToLocalTime (método).

En el ejemplo siguiente se conserva una matriz de DateTime valores enteros en un sistema en los Estados Unidos de EE. UU. Se restaura en un sistema en la zona UTC. El archivo que contiene los números enteros incluye un Int32 valor que indica el número total de Int64 valores que siguen inmediatamente a él.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

class Example
{
   private const string filename = @".\IntDates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      long[] ticks = new long[dates.Length];
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         ticks[ctr] = dates[ctr].ToUniversalTime().Ticks; 
      }
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryWriter bw = new BinaryWriter(fs);
      bw.Write(ticks.Length);
      foreach (var tick in ticks)
         bw.Write(tick);

      bw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      FileStream fs = new FileStream(filename, FileMode.Open);
      BinaryReader br = new BinaryReader(fs);
      int items;
      DateTime[] dates;

      try { 
         items = br.ReadInt32();
         dates = new DateTime[items];

         for (int ctr = 0; ctr < items; ctr++) {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
         }
      }   
      catch (EndOfStreamException) {
         Console.WriteLine("File corruption detected. Unable to restore data...");
         return;
      }   
      catch (IOException) {
         Console.WriteLine("Unspecified I/O error. Unable to restore data...");
         return;
      }
      // Thrown during array initialization.
      catch (OutOfMemoryException) {
         Console.WriteLine("File corruption detected. Unable to restore data...");
         return;
      }
      finally {      
         br.Close();
      }   

      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var value in dates)
         Console.WriteLine(value.ToString("f"));

      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

En lugar de guardar DateTime copia valores como cadenas o enteros, que, a continuación, tiene que convertir en DateTime valores, puede conservar DateTime valores mediante la serialización a una secuencia o archivo y, a continuación, restaurar ellos a través de la deserialización. En este caso, DateTimelos datos se serializan en algún formato de objeto especificado, y se restauran los objetos cuando se deserializan. Un formateador o serializador, como XmlSerializer o BinaryFormatter, controla el proceso de serialización y deserialización. Para obtener más información sobre la serialización y los tipos de serialización admitidas por .NET Framework, vea Serialización.

En el ejemplo siguiente se utiliza la XmlSerializer clase para serializar y deserializar DateTime leap de valores que representan todos los días del año en el siglo XXI. El resultado representa el resultado si se ejecuta el ejemplo en un sistema cuya referencia cultural actual es inglés (Reino Unido). Dado que nos hemos deserializar el DateTime objeto, el código no tiene que controlar las diferencias culturales de formatos de fecha y hora.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Xml.Serialization;

class Example
{
   private const string filename = @".\LeapYears.xml";

   public static void Main()
   {
      // Serialize the data.
      List<DateTime> leapYears = new List<DateTime>();
      for (int year = 2000; year <= 2100; year += 4) {
         if (DateTime.IsLeapYear(year)) 
            leapYears.Add(new DateTime(year, 2, 29));
      }
      DateTime[] dateArray = leapYears.ToArray();

      XmlSerializer serializer = new XmlSerializer(dateArray.GetType());
      TextWriter sw = new StreamWriter(filename);

      try {
         serializer.Serialize(sw, dateArray);
      }
      catch (InvalidOperationException e) {
         Console.WriteLine(e.InnerException.Message);         
      }
      finally {
         if (sw != null) sw.Close();
      }   

      // Deserialize the data.
      DateTime[] deserializedDates;
      using (FileStream fs = new FileStream(filename, FileMode.Open)) {
         deserializedDates = (DateTime[]) serializer.Deserialize(fs);
      } 

      // Display the dates.
      Console.WriteLine("Leap year days from 2000-2100 on an {0} system:",
                        Thread.CurrentThread.CurrentCulture.Name);
      int nItems = 0;
      foreach (var dat in deserializedDates) {
         Console.Write("   {0:d}     ", dat);
         nItems++;
         if (nItems % 5 == 0) 
               Console.WriteLine(); 
      }
   }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

El ejemplo anterior no incluye información de hora. Sin embargo, si un DateTime valor representa un momento determinado y se expresa como una hora local, debe convertirlo de la hora local en hora UTC antes de serializar mediante una llamada a la ToUniversalTime (método). Una vez deserializarlo, debe convertirlo a la hora UTC a la hora local mediante una llamada a la ToLocalTime (método). En el ejemplo siguiente se utiliza la BinaryFormatter clase para serializarDateTime datos en un sistema en los Estados Unidos Zona horaria estándar del Pacífico y deserializar en un sistema en la zona UTC.

using System;
using System.IO;
using System.Globalization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;

class Example
{
   private const string filename = @".\Dates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryFormatter bin = new BinaryFormatter();

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         dates[ctr] = dates[ctr].ToUniversalTime();
      }
      bin.Serialize(fs, dates);
      fs.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

      FileStream fs = new FileStream(filename, FileMode.Open);
      BinaryFormatter bin = new BinaryFormatter();
      DateTime[] dates = (DateTime[]) bin.Deserialize(fs);
      fs.Close();

      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var value in dates)
         Console.WriteLine(value.ToLocalTime().ToString("f"));

      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

Los ejemplos anteriores todos suponen que DateTime valores se expresan como hora local y convertir los valores entre la hora UTC y la hora local de modo que reflejen el mismo momento en el tiempo en los sistemas de origen y de destino. DateTime valores también pueden reflejar momentos en el tiempo en una zona horaria que no sea local y UTC. En este caso, porque el DateTime estructura no es compatible con la zona horaria, se debe serializar tanto la DateTimevalor y TimeZoneInfo objeto que representa la zona horaria. Para ello, cree un tipo cuyos campos incluyen tanto la DateTime valor y su zona horaria. En el ejemplo siguiente se define un DateWithTimeZone estructura que ilustra cómo se puede hacer esto.

using System;

namespace DateTimeExtensions
{
   [Serializable] public struct DateWithTimeZone
   {
      private TimeZoneInfo tz;
      private DateTime dt;

      public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
      {
         dt = dateValue;
         if (timeZone == null)
            tz = TimeZoneInfo.Local;
         else
            tz = timeZone;
      }   

      public TimeZoneInfo TimeZone 
      { get { return (tz); }
        set { tz = value; } }

      public DateTime DateTime 
      { get { return (dt); }
        set { dt = value; } }
   }
}
System_CAPS_importantImportante

El DateWithTimeZone estructura se utiliza en los dos ejemplos siguientes, que serializar y deserializar la matriz de DateWithTimeZone objetos. Para ejecutar los ejemplos, primero cree una biblioteca de clases que contiene la DateWithTimeZone estructura y, a continuación, agregue una referencia a ella cuando se compila cada ejemplo.

Mediante el uso de la DateWithTimeZone estructura, a continuación, puede guardar la fecha y hora junto con información de zona horaria. En el ejemplo siguiente se utiliza la BinaryFormatter clase para serializar una matriz de DateWithTimeZoneobjetos.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   public static void Main()
   {
      DateWithTimeZone[] dates= { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),  
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0), 
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),  
                                  new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),  
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),  
                                  new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0), 
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
      FileStream fs = new FileStream(@".\Schedule.bin", FileMode.Create);
      BinaryFormatter formatter = new BinaryFormatter();
      try {
         formatter.Serialize(fs, dates);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Serialization failed. Reason: {0}", e.Message);
      }   
      finally {
         if (fs != null) fs.Close();
      }
   }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time

El ejemplo siguiente llama a la BinaryFormatter.Deserialize método deserializarlo.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   private const string filename = @".\Schedule.bin";

   public static void Main()
   {
      FileStream fs;
      if (File.Exists(filename))
         fs = new FileStream(filename, FileMode.Open);
      else {
         Console.WriteLine("Unable to find file to deserialize.");
         return;
      }

      BinaryFormatter formatter = new BinaryFormatter();
      DateWithTimeZone[] dates;
      try {
         dates = (DateWithTimeZone[]) formatter.Deserialize(fs);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Deserialization failed. Reason: {0}", e.Message);
      }   
      finally {
         if (fs != null) fs.Close();
      }
   }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time

Un DateTime valor que se transfiere a una aplicación COM, a continuación, se vuelve a transferir a una aplicación administrada, se dice que la ida y vuelta. Sin embargo, un DateTime no es el valor que especifica una hora ida y vuelta como cabría esperar.

Si se vuelta sólo una hora, como 3 P.M., la fecha final y la hora es 30 de diciembre de 1899 de la era cristiana a 3:00 P.M., en lugar del 1 de enero de 0001 de la era cristiana a 3:00 P.M. Esto sucede porque .NET Framework y COM suponen una fecha predeterminada cuando se especifica solo una vez. Sin embargo, el sistema COM supone una fecha base el 30 de diciembre de 1899 de la era cristiana mientras que .NET Framework supone una fecha base 1 de enero, 0001 de la era cristiana

Cuando sólo una vez se pasa de .NET Framework a COM, se realiza un procesamiento especial convierte la hora en el formato utilizado por COM. Cuando sólo una vez se pasa de COM a .NET Framework, no se realiza ningún procesamiento especial, ya que podrían dañar legítimas fechas y horas en o antes del 30 de diciembre de 1899. Esto también significa que si una fecha comienza su ida y vuelta desde COM, .NET Framework y COM conservan la fecha.

El comportamiento de .NET Framework y COM significa que si la ida y vuelta de aplicación un DateTime que sólo especifica una hora, la aplicación debe recordar modificar u omitir los datos erróneos desde el último DateTime objeto.

En el ejemplo siguiente se muestra cómo comparar aproximadamente equivalente DateTime valores, aceptando un pequeño margen de diferencia cuando se declaran como iguales.

using System;

class DateTimeTester 
{
   static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
   {
      long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds 
                                                     % frequencyInSeconds;

      delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;

      return Math.Abs(delta) < windowInSeconds;
	}

	public static void Main() 
	{
      int window = 10;
      int freq = 60 * 60 * 2; // 2 hours;

      DateTime d1 = DateTime.Now;

      DateTime d2 = d1.AddSeconds(2 * window);
      DateTime d3 = d1.AddSeconds(-2 * window);
      DateTime d4 = d1.AddSeconds(window / 2);
      DateTime d5 = d1.AddSeconds(-window / 2);

      DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
      DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
      DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
      DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

      Console.WriteLine("d1 ({0}) ~= d1 ({1}): {2}",
                        d1, d1, RoughlyEquals(d1, d1, window, freq));
      Console.WriteLine("d1 ({0}) ~= d2 ({1}): {2}", 
                        d1, d2, RoughlyEquals(d1, d2, window, freq));
      Console.WriteLine("d1 ({0}) ~= d3 ({1}): {2}", 
                        d1, d3, RoughlyEquals(d1, d3, window, freq));
      Console.WriteLine("d1 ({0}) ~= d4 ({1}): {2}", 
                        d1, d4, RoughlyEquals(d1, d4, window, freq));
      Console.WriteLine("d1 ({0}) ~= d5 ({1}): {2}", 
                        d1, d5, RoughlyEquals(d1, d5, window, freq));

      Console.WriteLine("d1 ({0}) ~= d6 ({1}): {2}", 
                        d1, d6, RoughlyEquals(d1, d6, window, freq));
      Console.WriteLine("d1 ({0}) ~= d7 ({1}): {2}", 
                        d1, d7, RoughlyEquals(d1, d7, window, freq));
      Console.WriteLine("d1 ({0}) ~= d8 ({1}): {2}", 
                        d1, d8, RoughlyEquals(d1, d8, window, freq));
      Console.WriteLine("d1 ({0}) ~= d9 ({1}): {2}", 
                        d1, d9, RoughlyEquals(d1, d9, window, freq));
	}
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que aparecen modificar el estado de instancia realmente devuelven una nueva instancia inicializada con el nuevo valor. Como con cualquier otro tipo, leer y escribir en una variable compartida que contiene una instancia de este tipo deben estar protegidos por un bloqueo para garantizar la seguridad para subprocesos.

System_CAPS_cautionPrecaución

Asigne una instancia de este tipo no es segura para subprocesos en todas las plataformas de hardware, porque la representación binaria de la instancia puede ser demasiado grande para la asignación en una única operación atómica.

Volver al principio
Mostrar:
© 2016 Microsoft