Exportar (0) Imprimir
Expandir todo

DateTime (Estructura)

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

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

[SerializableAttribute] 
public struct DateTime : IComparable, IFormattable, IConvertible, 
	ISerializable, IComparable<DateTime>, IEquatable<DateTime>
/** @attribute SerializableAttribute() */ 
public final class DateTime extends ValueType implements IComparable, IFormattable, 
	IConvertible, ISerializable, IComparable<DateTime>, IEquatable<DateTime>
JScript admite el uso de estructuras, pero no admite la declaración de estructuras nuevas.

El tipo de valor de DateTime representa fechas y horas cuyos valores están comprendidos entre la medianoche (00:00:00) del 1 de enero de 0001 d.C. (Era Cristiana) y las 23:59:59 del 31 de diciembre de 9999 d.C. (Era Cristiana).

Los valores de hora se miden en unidades de 100 nanosegundos denominadas pasos, y una fecha concreta es el número de pasos transcurridos desde la medianoche (00:00) del 1 de enero de 0001 d.C. (Era Cristiana) en el calendario GregorianCalendar. Por ejemplo, un valor en pasos de 31241376000000000L representa la fecha de viernes, 1 de enero de 0100 a las 12:00:00 de la noche. Un valor DateTime siempre se expresa en el contexto de un calendario explícito o predeterminado.

Consideraciones de versión

En las versiones anteriores a la versión 2.0 de .NET Framework, la estructura DateTime contiene un campo de 64 bits formado por un campo de 2 bits no utilizados concatenado a un campo privado Ticks, que es un campo sin firma de 62 bits que contiene el número de pasos que representan la fecha y la hora. El valor del campo Ticks se puede obtener con la propiedad Ticks.

A partir de la versión 2.0 de .NET Framework, la estructura DateTime contiene un campo de 64 bits formado por un campo Kind privado concatenado al campo Ticks. El campo Kind es un campo de 2 bits que indica si la estructura DateTime representa una hora local o una hora universal coordinada (UTC), o si la hora UTC o local no están especificadas. El campo Kind se utiliza para controlar las conversiones entre la hora local y la hora UTC, pero no para realizar operaciones aritméticas o de comparación de horas. El valor del campo Kind se puede obtener con la propiedad Kind.

Valores de DateTime

Las descripciones de los valores de hora del tipo DateTime se suelen expresar utilizando el estándar de hora universal coordinada (UTC), que es el nombre con el que se conoce internacionalmente a la hora media de Greenwich (GMT). La hora universal coordinada es la hora que se mide en la longitud cero grados, punto de origen de UTC. El horario de verano no se aplica a UTC.

La hora local está relacionada con una zona horaria determinada. Una zona horaria se asocia a un desplazamiento de zona horaria, que es la diferencia medida en horas entre la zona horaria y el punto de origen de UTC. Además, a la hora local le afecta opcionalmente el horario de verano, que agrega o resta una hora a la duración del día. Por consiguiente, la hora local se calcula agregando el desplazamiento de zona horaria a la hora UTC y haciendo los ajustes oportunos por el horario de verano, en caso necesario. El desplazamiento de zona horaria en el punto de origen de UTC es cero.

La hora UTC es adecuada para los cálculos, las comparaciones y el almacenamiento de fechas y horas en los archivos. La hora local es apropiada para la presentación en las interfaces de usuario.

Si la propiedad Kind de un objeto DateTime es Unspecified, no queda especificado si la hora representada es hora local u hora UTC. Cada miembro de DateTime trata la hora no especificada del modo que le resulta más adecuado.

Operaciones con DateTime

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

Las operaciones de conversión entre la hora local y la hora UTC tienen en cuenta el horario de verano, aunque las operaciones aritméticas y de comparación no lo hacen.

Los cálculos y las comparaciones de objetos DateTime sólo tienen significado si los objetos representan horas de la misma zona horaria. Por ese motivo, si no se especifica una zona horaria para los objetos, se presupone que el desarrollador cuenta con algún mecanismo externo, como una directiva o variable explícitas, que se puede utilizar para determinar la zona horaria en la que se ha creado el objeto DateTime.

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

Las operaciones que realizan los miembros del tipo DateTime tienen en cuenta una serie de detalles, como los años bisiestos y el número de días de un mes.

Diferencias entre DateTime y TimeSpan

Los tipos de valor de DateTime y TimeSpan se diferencian en que DateTime representa un instante de tiempo, mientras que TimeSpan representa un intervalo de tiempo. Esto significa, por ejemplo, que se puede restar una instancia de DateTime de otra para obtener el intervalo de tiempo entre ambas. O bien, se podría agregar un TimeSpan positivo al DateTime actual para calcular una fecha futura.

Se puede agregar o restar un intervalo de tiempo a un objeto DateTime. Los intervalos de tiempo pueden ser negativos o positivos y se pueden expresar en unidades como pasos o segundos, o como objetos TimeSpan.

Observaciones sobre la interoperabilidad COM

Se dice que un valor DateTime es de ida y vuelta cuando se transfiere a una aplicación COM y, a continuación, se vuelve a transferir a una aplicación administrada. Sin embargo, la acción de ida y vuelta de un valor de DateTime que especifique sólo una hora no tendrá el resultado que cabría esperar.

En una acción de ida y vuelta de sólo una hora, como las 15:00 horas, la fecha y hora finales serían el 30 de diciembre de 1899 de la Era Cristiana, a las 15:00 horas, en lugar del 1 de enero de 0001 de la Era Cristiana a las 15:00 horas. Esto sucede porque .NET Framework y COM suponen una fecha predeterminada cuando sólo se especifica una hora. Sin embargo, el sistema COM supone como fecha base el 30 de diciembre de 1899 de la Era Cristiana, mientras que .NET Framework supone que la fecha base es el 1 de enero de 0001, también de la Era Cristiana.

Cuando sólo se pasa una hora de .NET Framework a COM, se realiza un proceso especial que convierte la hora al formato utilizado por COM. Cuando sólo se pasa una hora de COM a .NET Framework, no se realiza un procesamiento especial puesto que se podrían dañar las fechas y horas válidas correspondientes al 30 de diciembre de 1899 y las anteriores. Esto también significa que una si una fecha comienza una acción de ida y vuelta empezando en COM, .NET Framework y COM conservan la fecha.

El comportamiento de .NET Framework y COM supone que si la aplicación ejecuta una acción de ida y vuelta respecto de un objeto DateTime que sólo especifica una hora, la aplicación no puede olvidarse de modificar u omitir los datos erróneos provenientes del objeto DateTime final.

Interfaces implementadas

Este tipo implementa interfaces IComparable, IComparable, IFormattable e IConvertible. Utilice la clase Convert para las conversiones en lugar de la implementación de miembro de interfaz explícita de IConvertible de este tipo.

En el ejemplo de código siguiente se muestra cómo comparar los valores de DateTime más o menos equivalentes, aceptando un pequeño margen de diferencia cuando se les declara iguales.

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 ~= d1 [true]: " + RoughlyEquals(d1, d1, window, freq));
            Console.WriteLine("d1 ~= d2 [false]: " + RoughlyEquals(d1, d2, window, freq));
            Console.WriteLine("d1 ~= d3 [false]: " + RoughlyEquals(d1, d3, window, freq));
            Console.WriteLine("d1 ~= d4 [true]: " + RoughlyEquals(d1, d4, window, freq));
            Console.WriteLine("d1 ~= d5 [true]: " + RoughlyEquals(d1, d5, window, freq));

            Console.WriteLine("d1 ~= d6 [false]: " + RoughlyEquals(d1, d6, window, freq));
            Console.WriteLine("d1 ~= d7 [false]: " + RoughlyEquals(d1, d7, window, freq));
            Console.WriteLine("d1 ~= d8 [true]: " + RoughlyEquals(d1, d8, window, freq));
            Console.WriteLine("d1 ~= d9 [true]: " + RoughlyEquals(d1, d9, window, freq));


	}
}

class DateTimeTester
{
    public static boolean RoughlyEquals(DateTime time, 
        DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
    {
        long delta = (long)((TimeSpan)timeWithWindow.Subtract(time)).
            get_TotalSeconds() % frequencyInSeconds;
        delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
        return (System.Convert.ToBoolean(System.Math.Abs(delta) 
            < windowInSeconds));
    } //RoughlyEquals

    public static void main(String[] args)
    {
        int window = 10;
        int freq = 60 * 60 * 2; // 2 hours;
        DateTime d1 = DateTime.get_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 ~= d1 [true]: " 
            + RoughlyEquals(d1, d1, window, freq));
        Console.WriteLine("d1 ~= d2 [false]: " 
            + RoughlyEquals(d1, d2, window, freq));
        Console.WriteLine("d1 ~= d3 [false]: " 
            + RoughlyEquals(d1, d3, window, freq));
        Console.WriteLine("d1 ~= d4 [true]: " 
            + RoughlyEquals(d1, d4, window, freq));
        Console.WriteLine("d1 ~= d5 [true]: " 
            + RoughlyEquals(d1, d5, window, freq));
        Console.WriteLine("d1 ~= d6 [false]: " 
            + RoughlyEquals(d1, d6, window, freq));
        Console.WriteLine("d1 ~= d7 [false]: " 
            + RoughlyEquals(d1, d7, window, freq));
        Console.WriteLine("d1 ~= d8 [true]: " 
            + RoughlyEquals(d1, d8, window, freq));
        Console.WriteLine("d1 ~= d9 [true]: " 
            + RoughlyEquals(d1, d9, window, freq));
    } //main 
} //DateTimeTester 

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.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft