Exporter (0) Imprimer
Développer tout

DateTime, structure

Représente un instant, généralement exprimé sous la forme d'une date ou d'une heure.

Espace de noms : System
Assembly : mscorlib (dans 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 prend en charge l'utilisation de structures mais pas la déclaration de nouvelles structures.

Le type valeur DateTime représente des dates et des heures dont la valeur est comprise entre 12:00:00 (minuit), le 1er janvier de l'année 0001 de l'ère commune et 11:59:59 (onze heures du soir), le 31 décembre de l'année 9999 après J.C. (ère commune).

Les valeurs de date sont mesurées en unités de 100 nanosecondes, appelées graduations, et une date spécifique correspond au nombre de graduations écoulées à compter de 12:00 (minuit), le 1er janvier de l'année 0001 après J.C. de l'ère commune dans le calendrier GregorianCalendar. Par exemple, une valeur de graduations égale à 31241376000000000L représente la date du vendredi 1er janvier 0100 12:00:00 (minuit). Une valeur DateTime est toujours exprimée dans le contexte d'un calendrier explicite ou par défaut.

Considérations de version

Dans les versions antérieures du .NET Framework version 2.0, la structure DateTime contient un champ 64 bits composé d'un champ de 2 bits inutilisé concaténé avec un champ Ticks privé qui est un champ non signé de 62 bits qui contient le nombre de graduations qui représentent la date et heure. La valeur du champ Ticks peut être obtenue avec la propriété Ticks.

Depuis .NET Framework version 2.0, la structure DateTime contient un champ de 64 bits composé d'un champ Kind privé concaténé avec le champ Ticks. Le champ Kind est un champ de 2 bits qui indique si la structure DateTime représente une heure locale, une heure universelle (UTC, Coordinated Universal Time), ou si l'UTC ou l'heure locale ne sont pas spécifiées. Le champ Kind est utilisé pour gérer les conversions entre l'heure locale et l'heure UTC, mais pas les comparaisons d'heure ou l'arithmétique. La valeur du champ Kind peut être obtenue avec la propriété Kind.

Valeurs DateTime

Dans le type DateTime, les valeurs d'heure sont souvent exprimées en heure universelle (UTC), précédemment connue sous le nom d'heure de Greenwich (GMT). Le temps universel coordonné est l'heure mesurée à la longitude zéro, le point de départ de l'UTC. L'heure d'été ne s'applique pas à l'UTC.

L'heure locale est relative à un fuseau horaire particulier. Un fuseau horaire est associé à un décalage horaire, qui est le décalage du fuseau horaire mesuré en heures par rapport au point de départ UTC. De plus, l'heure locale peut en option être affectée par l'heure d'été, qui ajoute ou soustrait une heure de la journée. Par conséquent, l'heure locale est calculée en ajoutant l'offset de fuseau horaire à l'UTC et en réglant l'heure d'été si nécessaire. Le décalage horaire au point de départ de l'UTC est nul.

L'heure UTC est appropriée pour les calculs, les comparaisons et l'enregistrement des dates et heures dans les fichiers. L'heure locale est appropriée pour l'affichage dans les interfaces utilisateur.

Si la propriété Kind d'un objet DateTime est Unspecified, rien ne spécifie si l'heure représentée est locale ou UTC. Les membres DateTime individuels adaptent l'heure non spécifiée à ce membre.

Opérations DateTime

Un calcul effectué à l'aide d'une structure DateTime, telle que Add ou Subtract, ne modifie pas la valeur de la structure. En revanche, l'opération retourne une nouvelle structure DateTime dont la valeur est égale au résultat du calcul.

Les opérations de conversion entre l'heure locale et l'heure UTC tiennent compte de l'heure d'été, contrairement aux opérations arithmétiques et aux comparaisons.

Les calculs et les comparaisons d'objets DateTime n'ont de signification que si les objets représentent les heures dans le même fuseau horaire. Pour cette raison, si aucun fuseau horaire n'est spécifié pour les objets, le développeur dispose probablement d'un mécanisme externe, par exemple une variable ou une stratégie explicite, qui lui permet d'établir dans quel fuseau horaire un objet DateTime a été créé.

Lors de l'opération, chaque membre DateTime utilise implicitement le calendrier grégorien, à l'exception des constructeurs qui spécifient un calendrier, et des méthodes avec un paramètre dérivé de IFormatProvider, par exemple System.Globalization.DateTimeFormatInfo, qui spécifie implicitement un calendrier.

Les opérations effectuées par les membres du type DateTime prennent en considération des éléments tels que les années bissextiles et le nombre de jours d'un mois.

DateTime et TimeSpan

Les types valeur DateTime et TimeSpan se distinguent par le fait que DateTime représente un instant, tandis que TimeSpan représente un intervalle de temps. Cela signifie, par exemple, que vous pouvez soustraire une instance DateTime d'une autre pour obtenir l'intervalle de temps les séparant. De la même façon, vous pouvez ajouter un TimeSpan positif au DateTime en cours pour calculer une date ultérieure.

Vous pouvez ajouter ou soustraire un intervalle de temps d'un objet DateTime. Les intervalles de temps peuvent être négatifs ou positifs ; ils peuvent être exprimés en unités telles que les graduations ou les secondes ou comme un objet TimeSpan.

Considérations sur COM Interop

On dit d'une valeur DateTime qui est transférée à une application COM, puis transférée de nouveau à une application managée, qu'elle effectue un aller-retour. Toutefois, une valeur DateTime qui ne spécifie qu'une heure n'effectue pas un aller-retour, comme vous vous en doutez.

Si seule une heure effectue un « aller-retour », par exemple 15 heures, la date et l'heure finales sont le 30 décembre 1899 (ère commune) à 15 heures, au lieu du 1er janvier 0001 (ère commune) à 15 heures. Cela s'explique par le fait que le .NET Framework et COM adoptent une date par défaut lorsque seule une heure est spécifiée. Toutefois, le système COM adopte le 30 décembre 1899 (ère commune) comme date de base, tandis que le .NET Framework adopte le 1er janvier 0001 (ère commune) comme date de base.

Lorsque seule une heure est passée du .NET Framework à COM, un traitement spécial qui convertit l'heure au format utilisé par COM est exécuté. Quand seule une heure est passée de COM au .NET Framework, aucun traitement spécial n'est exécuté parce que cela altérerait les dates et les heures antérieures ou égales au 30 décembre 1899. Cela signifie également si une date démarre son aller-retour à partir de COM, le .NET Framework et COM conservent la date.

Le comportement du .NET Framework et de COM signifie que si votre application réalise un aller-retour de DateTime qui spécifie uniquement une heure, elle doit veiller à modifier ou à ignorer la date erronée du dernier objet DateTime.

Interfaces implémentées

Ce type implémente les interfaces IComparable, IComparable, IFormattable et IConvertible. Pour les conversions, utilisez la classe Convert au lieu de l'implémentation du membre d'interface explicite de IConvertible de ce type.

L'exemple suivant illustre la comparaison de valeurs DateTime à peu près équivalentes, une légère différence est acceptée lorsqu'elles sont déclarées « égales ».

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 

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0, 1.0

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft