DateTime Structure

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

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

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializable

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializable

public value class DateTime : IComparable, IConvertible, IFormattable

public value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable

public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable

public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable

public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable

[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable

[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable

public struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable

type DateTime = struct
    interface IConvertible
    interface IFormattable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface ISerializable

type DateTime = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable

[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
    interface ISerializable

type DateTime = struct
    interface IFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattable

Public Structure DateTime
Implements IComparable, IConvertible, IFormattable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable

Héritage

Object

ValueType

DateTime

Attributs

SerializableAttribute

Implémente

IComparable IComparable<DateTime> IConvertible IEquatable<DateTime> IFormattable ISerializable ISpanFormattable

Remarques

Important

Les ères des calendriers japonais sont basées sur le règne de l’empereur et sont donc amenées à changer. Par exemple, le 1 mai 2019 a marqué le début de l’ère Reiwa dans JapaneseCalendar et JapaneseLunisolarCalendar. Ce changement d’ère affecte toutes les applications qui utilisent ces calendriers. Pour plus d’informations et pour déterminer si vos applications sont affectées, consultez gestion d’une nouvelle ère dans le calendrier japonais dans .net. pour plus d’informations sur le test de vos applications sur Windows systèmes afin de garantir leur préparation au changement d’ère, consultez préparer votre application pour la modification de l’ère japonaise. Pour les fonctionnalités de .NET qui prennent en charge les calendriers avec plusieurs ères et pour les meilleures pratiques lorsque vous travaillez avec des calendriers qui prennent en charge plusieurs ères, consultez utilisation des ères.

Liens rapides vers l’exemple de code

Notes

Certains exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.

Le fuseau horaire local de l’exécuteur de code en ligne et du terrain de jeu inline Try.NET est le temps universel coordonné, ou UTC. Cela peut affecter le comportement et la sortie d’exemples qui illustrent les types DateTime, DateTimeOffset et TimeZoneInfo ainsi que leurs membres.

Cet article contient plusieurs exemples qui utilisent le DateTime type :

Exemples d’initialisation

• Appeler un constructeur
• Appeler le constructeur sans paramètre implicite
• Assignation à partir de la valeur de retour
• Analyse d’une chaîne qui représente une date et une heure
• Visual Basic syntaxe pour initialiser une date et une heure

Mise en forme des DateTime objets en tant que chaînes

• Utiliser le format de date et d’heure par défaut
• Mettre en forme une date et une heure à l’aide d’une culture spécifique
• Mettre en forme une date et une heure à l’aide d’une chaîne de format standard ou personnalisée
• Spécifier une chaîne de format et une culture spécifique
• Mettre en forme une date et une heure à l’aide de la norme ISO 8601 pour les services Web

Analyse de chaînes en tant qu' DateTime objets

• Utiliser Parse ou TryParse pour convertir une chaîne en date et heure
• Utilisez ParseExact ou TryParseExact pour convertir une chaîne dans un format connu
• Conversion de la représentation de chaîne ISO 8601 en date et heure

DateTime 768

• Explorer la résolution des valeurs de date et d’heure
• Comparaison de l’égalité au sein d’une tolérance

Culture et calendriers

• Afficher les valeurs de date et d’heure à l’aide de calendriers spécifiques à la culture
• Analyser les chaînes en fonction d’un calendrier spécifique à la culture
• Initialiser une date et une heure à partir du calendrier d’une culture spécifique
• Accès aux propriétés de date et d’heure à l’aide du calendrier d’une culture spécifique
• Récupération de la semaine de l’année à l’aide de calendriers spécifiques à la culture

Persistance

• Persistance des valeurs de date et d’heure sous forme de chaînes dans le fuseau horaire local
• Persistance des valeurs de date et d’heure sous forme de chaînes dans un format indifférent de culture et d’heure
• Persistance des valeurs de date et d’heure sous forme d’entiers
• Persistance des valeurs de date et d’heure à l’aide du XmlSerializer
• Persistance des valeurs de date et d’heure à l’aide du BinaryFormatter
• Persistance des valeurs de date et d’heure avec des données de fuseau horaire

Liens rapides vers les rubriques notes.

Cette section contient des rubriques pour de nombreuses utilisations courantes du DateTime struct :

• Initialisation d’un DateTime objet
• Valeurs DateTime et leurs représentations sous forme de chaîne
• Analyse des valeurs DateTime à partir de chaînes
• Valeurs DateTime
• Opérations DateTime
• Résolution DateTime
• Valeurs et calendriers DateTime
• Persistance des valeurs DateTime
• DateTime et TimeSpan
• Comparaison de l’égalité dans la tolérance
• Considérations relatives au COM Interop

Le DateTime type de valeur représente les dates et les heures dont les valeurs sont comprises entre 00:00:00 (minuit), le 1er janvier 0001 Anno et (ère commune) et 11:59:59 31 décembre 9999 après j.-c. (notre ère) dans le calendrier grégorien.

Les valeurs d’heure sont mesurées en unités de 100 nanosecondes appelées battements. Une date particulière est le nombre de cycles depuis le 12:00 minuit, le 1er janvier 0001 apr. J.-C. (NOTRE ÈRE) dans le GregorianCalendar calendrier. Le nombre exclut les graduations qui seraient ajoutées par les secondes bissextiles. Par exemple, la valeur des graduations de 31241376000000000L représente la date du vendredi 01 janvier 0100 12:00:00 minuit. Une DateTime valeur est toujours exprimée dans le contexte d’un calendrier explicite ou par défaut.

Notes

Si vous utilisez une valeur des graduations que vous souhaitez convertir en un autre intervalle de temps, par exemple des minutes ou des secondes, vous devez utiliser la constante,,, TimeSpan.TicksPerDay TimeSpan.TicksPerHour TimeSpan.TicksPerMinute TimeSpan.TicksPerSecond ou TimeSpan.TicksPerMillisecond pour effectuer la conversion. Par exemple, pour ajouter le nombre de secondes représenté par un nombre spécifié de graduations au Second composant d’une DateTime valeur, vous pouvez utiliser l’expression dateValue.Second + nTicks/Timespan.TicksPerSecond .

vous pouvez afficher la source de la totalité de l’ensemble d’exemples dans cet article, Visual Basic ou C# , dans le référentiel docs sur GitHub.

Notes

La structure est une alternative à la DateTime structure permettant d’utiliser des valeurs de date et d’heure dans des fuseaux horaires particuliers DateTimeOffset . La DateTimeOffset structure stocke les informations de date et d’heure dans un DateTime champ privé et le nombre de minutes pendant lesquelles cette date et cette heure diffèrent de l’heure UTC dans un Int16 champ privé. Cela permet à une valeur de DateTimeOffset refléter l’heure dans un fuseau horaire particulier, alors qu’une DateTime valeur peut uniquement refléter l’heure UTC et l’heure du fuseau horaire local. Pour savoir quand utiliser la DateTime structure ou la DateTimeOffset structure lors de l’utilisation de valeurs de date et d’heure, consultez choix entre DateTime, DateTimeOffset, TimeSpan et TimeZoneInfo.

Initialisation d’un objet DateTime

Vous pouvez affecter une valeur initiale à une nouvelle DateTime valeur de différentes manières :

• Appel d’un constructeur, soit lorsque vous spécifiez des arguments pour des valeurs, soit à l’aide du constructeur sans paramètre implicite.
• Assignation d’un DateTime à la valeur de retour d’une propriété ou d’une méthode.
• Analyse d’une DateTime valeur à partir de sa représentation sous forme de chaîne.
• utilisation des fonctionnalités de langage spécifiques à Visual Basic pour instancier un DateTime .

Les extraits de code suivants présentent des exemples de chacun :

Appeler les constructeurs

Vous appelez l’une des surcharges du DateTime constructeur qui spécifie des éléments de la valeur de date et d’heure (par exemple, l’année, le mois et le jour, ou le nombre de graduations). Le code suivant crée une date spécifique à l’aide du DateTime constructeur qui spécifie l’année, le mois, le jour, l’heure, la minute et la seconde.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)

var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

Vous appelez le DateTime constructeur sans paramètre implicite de la structure lorsque vous souhaitez qu’un DateTime soit initialisé à sa valeur par défaut. (Pour plus d’informations sur le constructeur sans paramètre implicite d’un type valeur, consultez types valeur.) Certains compilateurs prennent également en charge la déclaration d’une DateTime valeur sans lui assigner explicitement une valeur. La création d’une valeur sans initialisation explicite entraîne également la valeur par défaut. l’exemple suivant illustre le DateTime constructeur sans paramètre implicite en C# et Visual Basic, ainsi qu’une DateTime déclaration sans assignation dans Visual Basic.

Dim dat1 As 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(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))

var 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));

Affectation d’une valeur calculée

Vous pouvez assigner à l' DateTime objet une valeur de date et d’heure retournée par une propriété ou une méthode. L’exemple suivant affecte la date et l’heure actuelles, la date et l’heure en temps universel coordonné (UTC, Universal Time Coordinated) et la date actuelle à trois nouvelles DateTime variables.

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today

DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;

Analyse d’une chaîne qui représente une valeur DateTime

Les Parse méthodes,, ParseExact TryParse et TryParseExact convertissent toutes une chaîne en sa valeur équivalente de date et d’heure. Les exemples suivants utilisent les Parse ParseExact méthodes et pour analyser une chaîne et la convertir en DateTime valeur. Le deuxième format utilise un formulaire pris en charge par la norme ISO 8601 pour représenter une date et une heure sous forme de chaîne. Cette représentation standard est souvent utilisée pour transférer des informations de date dans les services Web.

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)

var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

Les TryParse TryParseExact méthodes et indiquent si une chaîne est une représentation valide d’une DateTime valeur et, si c’est le cas, effectue la conversion.

Syntaxe spécifique au langage pour Visual Basic

l’instruction Visual Basic suivante initialise une nouvelle DateTime valeur.

Dim date1 As Date = #5/1/2008 8:30:52AM#

Valeurs DateTime et leurs représentations sous forme de chaîne

En interne, toutes les DateTime valeurs sont représentées en tant que nombre de battements (nombre d’intervalles de 100 nanosecondes) qui se sont écoulés 12:00:00 depuis le 1er janvier 0001 à minuit. La DateTime valeur réelle est indépendante de la façon dont cette valeur apparaît lorsqu’elle s’affiche. L’apparence d’une DateTime valeur est le résultat d’une opération de mise en forme qui convertit une valeur en sa représentation sous forme de chaîne.

L’apparence des valeurs de date et d’heure dépend de la culture, des normes internationales, des exigences de l’application et de la préférence personnelle. La DateTime structure offre une grande souplesse dans la mise en forme des valeurs de date et d’heure par le biais de surcharges de ToString . La méthode par défaut DateTime.ToString() retourne la représentation sous forme de chaîne d’une valeur de date et d’heure à l’aide du modèle de date rapide et d’heure longue de la culture actuelle. L’exemple suivant utilise la méthode par défaut DateTime.ToString() . Elle affiche la date et l’heure à l’aide du modèle de date et d’heure courtes pour la culture actuelle. La culture en-US est la culture actuelle sur l’ordinateur sur lequel l’exemple a été exécuté.

var 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

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

Vous devrez peut-être mettre en forme des dates dans une culture spécifique pour prendre en charge des scénarios Web où le serveur peut se trouver dans une culture différente de celle du client. Vous spécifiez la culture à l’aide de la DateTime.ToString(IFormatProvider) méthode pour créer la représentation de date et d’heure courtes dans une culture spécifique. L’exemple suivant utilise la DateTime.ToString(IFormatProvider) méthode pour afficher la date et l’heure à l’aide du modèle de date et d’heure courtes pour la culture fr-fr.

var 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

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00

D’autres applications peuvent nécessiter des représentations sous forme de chaîne différentes d’une date. La DateTime.ToString(String) méthode retourne la représentation sous forme de chaîne définie par un spécificateur de format standard ou personnalisé à l’aide des conventions de mise en forme de la culture actuelle. L’exemple suivant utilise la DateTime.ToString(String) méthode pour afficher le modèle de date et d’heure complet pour la culture en-US, la culture actuelle sur l’ordinateur sur lequel l’exemple a été exécuté.

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

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

Enfin, vous pouvez spécifier à la fois la culture et le format à l’aide de la DateTime.ToString(String, IFormatProvider) méthode. L’exemple suivant utilise la DateTime.ToString(String, IFormatProvider) méthode pour afficher le modèle de date et d’heure complet pour la culture fr-fr.

var 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

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

La DateTime.ToString(String) surcharge peut également être utilisée avec une chaîne de format personnalisée pour spécifier d’autres formats. L’exemple suivant montre comment mettre en forme une chaîne à l’aide du format standard ISO 8601 utilisé pour les services Web. Le format ISO 8601 n’a pas de chaîne de format standard correspondante.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"));
// Displays 20080301T07:00:00Z

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"))
' Displays 20080301T07:00:00Z

Pour plus d’informations sur la mise en forme des DateTime valeurs, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.

Analyse des valeurs DateTime à partir de chaînes

L’analyse convertit la représentation sous forme de chaîne d’une date et d’une heure en une DateTime valeur. En règle générale, les chaînes de date et d’heure ont deux utilisations différentes dans les applications :

• Une date et une heure prennent diverses formes et reflètent les conventions de la culture actuelle ou d’une culture spécifique. Par exemple, une application permet à un utilisateur dont la culture actuelle est en-US d’entrer une valeur de date sous la forme « 12/15/2013 » ou « 15 décembre 2013 ». Il permet à un utilisateur dont la culture actuelle est en-GB d’entrer une valeur de date sous la forme « 15/12/2013 » ou « 15 décembre 2013 ».

• Une date et une heure sont représentées dans un format prédéfini. Par exemple, une application sérialise une date sous la forme « 20130103 » indépendamment de la culture sur laquelle l’application s’exécute. Une application peut nécessiter l’entrée de dates dans le format de date abrégé de la culture actuelle.

Vous utilisez la Parse TryParse méthode ou pour convertir une chaîne de l’un des formats de date et d’heure communs utilisés par une culture en DateTime valeur. L’exemple suivant montre comment vous pouvez utiliser TryParse pour convertir des chaînes de date dans différents formats spécifiques à une culture en une DateTime valeur. Il remplace la culture actuelle par l’anglais (Grande-Bretagne) et appelle la GetDateTimeFormats() méthode pour générer un tableau de chaînes de date et d’heure. Il passe ensuite chaque élément du tableau à la TryParse méthode. La sortie de l’exemple montre que la méthode d’analyse a pu convertir chacune des chaînes de date et d’heure spécifiques à la culture.

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

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

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    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($"   {badFormat}");
}
// Press "Run" to see the output.

Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' 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

Vous utilisez les ParseExact TryParseExact méthodes et pour convertir une chaîne qui doit correspondre à un format ou des formats particuliers en une DateTime valeur. Vous spécifiez une ou plusieurs chaînes de format de date et d’heure en tant que paramètre de la méthode d’analyse. L’exemple suivant utilise la TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) méthode pour convertir les chaînes qui doivent être au format « AAAAMMJJ » ou « HHmmss » en DateTime valeurs.

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,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {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

Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' 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

Une utilisation courante de ParseExact est de convertir une représentation sous forme de chaîne à partir d’un service Web, généralement au format ISO 8601 standard. Le code suivant affiche la chaîne de format correcte à utiliser :

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");

Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

Si une chaîne ne peut pas être analysée, les Parse ParseExact méthodes et lèvent une exception. Les TryParse TryParseExact méthodes et retournent une Boolean valeur qui indique si la conversion a réussi ou a échoué. Vous devez utiliser les TryParse TryParseExact méthodes ou dans les scénarios où les performances sont importantes. L’opération d’analyse pour les chaînes de date et d’heure a tendance à avoir un taux d’échec élevé et la gestion des exceptions est coûteuse. Utilisez ces méthodes si les chaînes sont entrées par les utilisateurs ou proviennent d’une source inconnue.

Pour plus d’informations sur l’analyse des valeurs de date et d’heure, consultez analyse des chaînes de date et d’heure.

Valeurs DateTime

Les descriptions des valeurs de temps dans le DateTime type sont souvent exprimées à l’aide de la norme de temps universel coordonné (UTC). L’heure universelle coordonnée est le nom internationalement reconnu pour l’heure de Greenwich (GMT). Le temps universel coordonné est le temps mesuré à zéro degré de longitude, le point d’origine UTC. L’heure d’été n’est pas applicable à l’heure UTC.

L’heure locale est relative à un fuseau horaire particulier. Un fuseau horaire est associé à un décalage de fuseau horaire. Un décalage de fuseau horaire correspond au déplacement du fuseau horaire mesuré en heures à partir du point d’origine UTC. En outre, l’heure locale est éventuellement affectée par l’heure d’été, qui ajoute ou soustrait un ajustement d’intervalle de temps. L’heure locale est calculée en ajoutant le décalage de fuseau horaire au temps universel coordonné (UTC) et en ajustant l’heure d’été, si nécessaire. Le décalage de fuseau horaire au point d’origine UTC est égal à zéro.

L’heure UTC est adaptée aux calculs, aux comparaisons et au stockage des dates et de l’heure dans les fichiers. L’heure locale est appropriée pour l’affichage dans les interfaces utilisateur des applications de bureau. Les applications prenant en charge les fuseaux horaires (telles que de nombreuses applications Web) doivent également fonctionner avec un certain nombre d’autres fuseaux horaires.

Si la Kind propriété d’un DateTime objet a la valeur DateTimeKind.Unspecified , il n’est pas spécifié si l’heure représentée est l’heure locale, l’heure UTC ou une heure dans un autre fuseau horaire.

Résolution DateTime

Notes

Comme alternative à l’exécution d’opérations arithmétiques de date et d’heure sur des DateTime valeurs pour mesurer le temps écoulé, vous pouvez utiliser la Stopwatch classe.

La Ticks propriété exprime les valeurs de date et d’heure en unités de 1 10-millionième de seconde. La Millisecond propriété retourne les millièmes de seconde dans une valeur de date et d’heure. L’utilisation d’appels répétés à la DateTime.Now propriété pour mesurer le temps écoulé dépend de l’horloge système. l’horloge système sur les systèmes Windows 7 et Windows 8 a une résolution d’environ 15 millisecondes. Cette résolution affecte les petits intervalles de temps inférieurs à 100 millisecondes.

L’exemple suivant illustre la dépendance entre les valeurs de date et d’heure actuelles et la résolution de l’horloge système. Dans l’exemple, une boucle externe se répète 20 fois, et une boucle interne sert à retarder la boucle externe. Si la valeur du compteur de boucles externe est 10, un appel à la Thread.Sleep méthode introduit un délai de cinq millisecondes. L’exemple suivant montre le nombre de millisecondes retournées par les DateTime.Now.Milliseconds modifications de propriété uniquement après l’appel à Thread.Sleep .

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.

Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

Opérations DateTime

Un calcul à l’aide d’une DateTime structure, tel que Add ou Subtract , ne modifie pas la valeur de la structure. Au lieu de cela, le calcul retourne une nouvelle DateTime structure dont la valeur est le résultat du calcul.

Les opérations de conversion entre les fuseaux horaires (par exemple entre l’heure UTC et l’heure locale, ou entre un fuseau horaire et un autre) prennent en compte l’heure d’été, contrairement aux opérations arithmétiques et de comparaison.

La DateTime structure elle-même offre une prise en charge limitée de la conversion d’un fuseau horaire à un autre. Vous pouvez utiliser la ToLocalTime méthode pour convertir l’heure UTC en heure locale, ou vous pouvez utiliser la ToUniversalTime méthode pour convertir l’heure locale en heure UTC. Toutefois, un ensemble complet de méthodes de conversion de fuseau horaire est disponible dans la TimeZoneInfo classe. Vous convertissez l’heure de l’une des fuseaux horaires du monde en heure dans un autre fuseau horaire à l’aide de ces méthodes.

Les calculs et les comparaisons d' DateTime objets sont significatifs uniquement si les objets représentent des heures dans le même fuseau horaire. Vous pouvez utiliser un TimeZoneInfo objet pour représenter DateTime le fuseau horaire d’une valeur, bien que les deux soient faiblement couplés. Un DateTime objet n’a pas de propriété qui retourne un objet qui représente le fuseau horaire de cette valeur de date et d’heure. La Kind propriété indique si un DateTime représente UTC, heure locale ou n’est pas spécifié. Dans une application prenant en charge les fuseaux horaires, vous devez vous appuyer sur un mécanisme externe pour déterminer le fuseau horaire dans lequel un DateTime objet a été créé. Vous pouvez utiliser une structure qui encapsule la DateTime valeur et l' TimeZoneInfo objet qui représente le DateTime fuseau horaire de la valeur. Pour plus d’informations sur l’utilisation de l’heure UTC dans les calculs et les comparaisons avec des DateTime valeurs, consultez exécution d’opérations arithmétiques avec des dates et des heures.

Chaque DateTime membre utilise implicitement le calendrier grégorien pour effectuer son opération. Les exceptions sont des méthodes qui spécifient implicitement un calendrier. Celles-ci incluent des constructeurs qui spécifient un calendrier et des méthodes avec un paramètre dérivé de IFormatProvider , comme System.Globalization.DateTimeFormatInfo .

Les opérations effectuées par les membres du DateTime type prennent en compte des détails tels que les années bissextiles et le nombre de jours d’un mois.

Valeurs et calendriers DateTime

la bibliothèque de classes .NET Framework comprend un certain nombre de classes de calendrier, toutes dérivées de la Calendar classe. Il s'agit des éléments suivants :

• La classe ChineseLunisolarCalendar.
• La classe EastAsianLunisolarCalendar.
• La classe GregorianCalendar.
• La classe HebrewCalendar.
• La classe HijriCalendar.
• La classe JapaneseCalendar.
• La classe JapaneseLunisolarCalendar.
• La classe JulianCalendar.
• La classe KoreanCalendar.
• La classe KoreanLunisolarCalendar.
• La classe PersianCalendar.
• La classe TaiwanCalendar.
• La classe TaiwanLunisolarCalendar.
• La classe ThaiBuddhistCalendar.
• La classe UmAlQuraCalendar.

Important

Les ères des calendriers japonais sont basées sur le règne de l’empereur et sont donc amenées à changer. Par exemple, le 1 mai 2019 a marqué le début de l’ère Reiwa dans JapaneseCalendar et JapaneseLunisolarCalendar. Ce changement d’ère affecte toutes les applications qui utilisent ces calendriers. Pour plus d’informations et pour déterminer si vos applications sont affectées, consultez gestion d’une nouvelle ère dans le calendrier japonais dans .net. pour plus d’informations sur le test de vos applications sur Windows systèmes afin de garantir leur préparation au changement d’ère, consultez préparer votre application pour la modification de l’ère japonaise. Pour les fonctionnalités de .NET qui prennent en charge les calendriers avec plusieurs ères et pour les meilleures pratiques lorsque vous travaillez avec des calendriers qui prennent en charge plusieurs ères, consultez utilisation des ères.

Chaque culture utilise un calendrier par défaut défini par sa propriété en lecture seule CultureInfo.Calendar . Chaque culture peut prendre en charge un ou plusieurs calendriers définis par sa propriété en lecture seule CultureInfo.OptionalCalendars . Le calendrier actuellement utilisé par un CultureInfo objet spécifique est défini par sa DateTimeFormatInfo.Calendar propriété. Il doit s’agir de l’un des calendriers figurant dans le CultureInfo.OptionalCalendars tableau.

Le calendrier actuel d’une culture est utilisé dans toutes les opérations de mise en forme pour cette culture. Par exemple, le calendrier par défaut de la culture Thaï bouddhiste est le calendrier de l’ère Thaï bouddhiste, qui est représenté par la ThaiBuddhistCalendar classe. Lorsqu’un CultureInfo objet qui représente la culture Thaï bouddhiste est utilisé dans une opération de mise en forme de date et d’heure, le calendrier thaï de l’ère bouddhiste est utilisé par défaut. Le calendrier grégorien est utilisé uniquement si la propriété de la culture DateTimeFormatInfo.Calendar est modifiée, comme le montre l’exemple suivant :

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

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

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

Le calendrier actuel d’une culture est également utilisé dans toutes les opérations d’analyse pour cette culture, comme le montre l’exemple suivant.

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

Vous instanciez une DateTime valeur à l’aide des éléments de date et d’heure (nombre de l’année, du mois et du jour) d’un calendrier spécifique en appelant un constructeur DateTime qui comprend un calendar paramètre et en lui transmettant un Calendar objet qui représente ce calendrier. L’exemple suivant utilise les éléments de date et d’heure du ThaiBuddhistCalendar calendrier.

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016

Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime les constructeurs qui n’incluent pas de calendar paramètre partent du principe que les éléments de date et d’heure sont exprimés en tant qu’unités dans le calendrier grégorien.

Toutes les autres DateTime Propriétés et méthodes utilisent le calendrier grégorien. Par exemple, la DateTime.Year propriété retourne l’année dans le calendrier grégorien, et la DateTime.IsLeapYear(Int32) méthode suppose que le year paramètre est une année dans le calendrier grégorien. Chaque DateTime membre qui utilise le calendrier grégorien a un membre correspondant de la Calendar classe qui utilise un calendrier spécifique. Par exemple, la Calendar.GetYear méthode retourne l’année dans un calendrier spécifique, et la Calendar.IsLeapYear méthode interprète le year paramètre comme un nombre d’années dans un calendrier spécifique. L’exemple suivant utilise à la fois le DateTime et les membres correspondants de la ThaiBuddhistCalendar classe.

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True

Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

La DateTime structure comprend une DayOfWeek propriété qui retourne le jour de la semaine dans le calendrier grégorien. Il n’inclut pas de membre qui vous permet de récupérer le numéro de semaine de l’année. Pour récupérer la semaine de l’année, appelez la méthode du calendrier individuel Calendar.GetWeekOfYear . L'exemple suivant illustre cette situation.

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34

Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

Pour plus d’informations sur les dates et les calendriers, consultez utilisation des calendriers.

Persistance des valeurs DateTime

Vous pouvez conserver les DateTime valeurs de quatre façons :

• Vous les Convertissez en chaînes et persistance des chaînes.
• Vous les Convertissez en valeurs entières 64 bits (la valeur de la Ticks propriété) et persistance des entiers.
• Vous sérialisez les valeurs DateTime.
• Vous sérialisez les valeurs DateTime avec les informations de fuseau horaire.

Vous devez vous assurer que la routine qui restaure les DateTime valeurs ne perd pas de données ou ne lève pas d’exception, quelle que soit la technique choisie. DateTime les valeurs doivent aller-retour. Autrement dit, la valeur d’origine et la valeur restaurée doivent être identiques. Et si la valeur d’origine DateTime représente un seul instant, elle doit identifier le même moment lors de sa restauration.

Persistance des valeurs en tant que chaînes

Pour restaurer correctement les DateTime valeurs qui sont conservées sous forme de chaînes, procédez comme suit :

• Faites les mêmes hypothèses sur la mise en forme spécifique à la culture lorsque vous restaurez la chaîne comme lorsque vous l’avez rendue persistante. Pour vous assurer qu’une chaîne peut être restaurée sur un système dont la culture actuelle est différente de la culture du système sur lequel elle a été enregistrée, appelez la ToString surcharge pour enregistrer la chaîne à l’aide des conventions de la culture dite indifférente. Appelez la Parse(String, IFormatProvider, DateTimeStyles) TryParse(String, IFormatProvider, DateTimeStyles, DateTime) surcharge ou pour restaurer la chaîne à l’aide des conventions de la culture dite indifférente. N’utilisez jamais ToString() les Parse(String) TryParse(String, DateTime) surcharges, ou qui utilisent les conventions de la culture actuelle.

• Si la date représente un moment précis, assurez-vous qu’elle représente le même moment dans le temps qu’elle est restaurée, même sur un autre fuseau horaire. Convertissez la DateTime valeur en temps universel coordonné (UTC, Universal Time Coordinated) avant de l’enregistrer. Vous pouvez également sérialiser la valeur avec les informations de fuseau horaire. Pour plus d’informations sur cette approche, consultez sérialisation de données DateTime et de fuseau horaire.

L’erreur la plus courante effectuée lors de la persistance des DateTime valeurs sous forme de chaînes consiste à s’appuyer sur les conventions de mise en forme de la culture par défaut ou actuelle. Des problèmes surviennent si la culture actuelle est différente lors de l’enregistrement et de la restauration des chaînes. L’exemple suivant illustre ces problèmes. Elle économise cinq dates à l’aide des conventions de mise en forme de la culture actuelle, qui dans ce cas est l’anglais (États-Unis). Il restaure les dates à l’aide des conventions de mise en forme d’une autre culture, qui dans ce cas est l’anglais (Grande-Bretagne). Étant donné que les conventions de mise en forme des deux cultures sont différentes, deux des dates ne peuvent pas être restaurées et les trois dates restantes sont interprétées de manière incorrecte. En outre, si les valeurs de date et d’heure d’origine représentent des moments uniques dans le temps, les heures restaurées sont incorrectes, car les informations de fuseau horaire sont perdues.

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    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($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{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...

Public Sub PersistAsLocalStrings()
    SaveDatesAsStrings()
    RestoreDatesAsStrings()
End Sub

Private Sub SaveDatesAsStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParse(inputValue, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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...

Pour effectuer un aller-retour des DateTime valeurs, procédez comme suit :

1. Si les valeurs représentent des moments uniques, convertissez-les de l’heure locale en heure UTC en appelant la ToUniversalTime méthode.
2. Convertissez les dates en représentations sous forme de chaîne en appelant la ToString(String, IFormatProvider) String.Format(IFormatProvider, String, Object[]) surcharge ou. Utilisez les conventions de mise en forme de la culture dite indifférente en spécifiant CultureInfo.InvariantCulture comme provider argument. Spécifiez que la valeur doit aller-retour à l’aide de la chaîne de format standard « O » ou « R ».

Pour restaurer les valeurs persistantes DateTime sans perte de données, procédez comme suit :

1. Analysez les données en appelant ParseExact la TryParseExact surcharge ou. Spécifiez CultureInfo.InvariantCulture comme provider argument et utilisez la même chaîne de format standard que celle utilisée pour l' format argument lors de la conversion. Incluez la DateTimeStyles.RoundtripKind valeur dans l' styles argument.
2. Si les DateTime valeurs représentent des moments uniques dans le temps, appelez la ToLocalTime méthode pour convertir la date analysée de l’heure UTC en heure locale.

L’exemple suivant utilise la culture dite indifférente et la chaîne de format standard "O" pour s’assurer que les DateTime valeurs enregistrées et restaurées représentent le même moment dans le temps, indépendamment du système, de la culture ou du fuseau horaire des systèmes source et cible.

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    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 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine("Current Time Zone: {0}",
                      TimeZoneInfo.Local.DisplayName);
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    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($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        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...

Public Sub PersistAsInvariantStrings()
    SaveDatesAsInvariantStrings()
    RestoreDatesAsInvariantStrings()
End Sub

Private Sub SaveDatesAsInvariantStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
                                   If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsInvariantStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {0}",
                    TimeZoneInfo.Local.DisplayName)
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                          DateTimeStyles.RoundtripKind, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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...

Persistance des valeurs en tant qu’entiers

Vous pouvez conserver une date et une heure sous la forme d’une Int64 valeur qui représente un nombre de graduations. Dans ce cas, vous n’avez pas besoin de prendre en compte la culture des systèmes sur lesquels les DateTime valeurs sont conservées et restaurées.

Pour rendre une DateTime valeur persistante sous la forme d’un entier :

• Si les DateTime valeurs représentent des moments uniques dans le temps, convertissez-les en temps UTC en appelant la ToUniversalTime méthode.
• Récupère le nombre de graduations représenté par la DateTime valeur de sa Ticks propriété.

Pour restaurer une DateTime valeur qui a été rendue persistante sous la forme d’un entier :

1. Instanciez un nouvel DateTime objet en passant la Int64 valeur au DateTime(Int64) constructeur.
2. Si la DateTime valeur représente un moment donné dans le temps, convertissez-la de l’heure UTC en heure locale en appelant la ToLocalTime méthode.

L’exemple suivant conserve un tableau de DateTime valeurs sous la forme d’entiers sur un système situé dans le fuseau horaire Pacifique (États-Unis). Il la restaure sur un système situé dans la zone UTC. Le fichier qui contient les entiers inclut une Int32 valeur qui indique le nombre total de Int64 valeurs qui le suivent immédiatement.

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var 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;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var 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 RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, 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 {Thread.CurrentThread.CurrentCulture.Name} system:");
    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...

Public Sub PersistAsIntegers()
    SaveDatesAsIntegers()
    RestoreDatesAsIntegers()
End Sub

Private Sub SaveDatesAsIntegers()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim ticks(dates.Length - 1) As Long
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
    Next
    Dim fs As New FileStream(filenameInts, FileMode.Create)
    Dim bw As New BinaryWriter(fs)
    bw.Write(ticks.Length)
    For Each tick In ticks
        bw.Write(tick)
    Next
    bw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsIntegers()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim fs As New FileStream(filenameInts, FileMode.Open)
    Dim br As New BinaryReader(fs)
    Dim items As Integer
    Dim dates As DateTime()

    Try
        items = br.ReadInt32()
        ReDim dates(items - 1)

        For ctr As Integer = 0 To items - 1
            Dim ticks As Long = br.ReadInt64()
            dates(ctr) = New DateTime(ticks).ToLocalTime()
        Next
    Catch e As EndOfStreamException
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Catch e As IOException
        Console.WriteLine("Unspecified I/O error. Unable to restore data...")
        Exit Sub
    Catch e As OutOfMemoryException     'Thrown in array initialization.
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Finally
        br.Close()
    End Try

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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...

Sérialisation des valeurs DateTime

Vous pouvez conserver DateTime les valeurs via la sérialisation dans un flux ou un fichier, puis les restaurer via la désérialisation. DateTime les données sont sérialisées dans un format d’objet spécifié. Les objets sont restaurés lorsqu’ils sont désérialisés. Un formateur ou un sérialiseur, tel que XmlSerializer ou BinaryFormatter , gère le processus de sérialisation et de désérialisation. pour plus d’informations sur la sérialisation et les types de sérialisation pris en charge par le .NET Framework, consultez sérialisation.

L’exemple suivant utilise la XmlSerializer classe pour sérialiser et désérialiser des DateTime valeurs. Les valeurs représentent tous les jours de l’année bissextile du vingt-et-unième siècle. La sortie représente le résultat si l’exemple est exécuté sur un système dont la culture actuelle est l’anglais (Grande-Bretagne). Étant donné que vous avez désérialisé l' DateTime objet lui-même, le code n’a pas à gérer les différences culturelles dans les formats de date et d’heure.

public static void PersistAsXML()
{
    // Serialize the data.
    var 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();

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

    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 (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[])serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    foreach (var dat in deserializedDates)
    {
        Console.Write($"   {dat:d}     ");
        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

Public Sub PersistAsXml()
    ' Serialize the data.
    Dim leapYears As New List(Of DateTime)()
    For year As Integer = 2000 To 2100 Step 4
        If Date.IsLeapYear(year) Then
            leapYears.Add(New Date(year, 2, 29))
        End If
    Next
    Dim dateArray As DateTime() = leapYears.ToArray()

    Dim serializer As New XmlSerializer(dateArray.GetType())
    Dim sw As TextWriter = New StreamWriter(filenameXml)

    Try
        serializer.Serialize(sw, dateArray)
    Catch e As InvalidOperationException
        Console.WriteLine(e.InnerException.Message)
    Finally
        If sw IsNot Nothing Then sw.Close()
    End Try

    ' Deserialize the data.
    Dim deserializedDates As Date()
    Using fs As New FileStream(filenameXml, FileMode.Open)
        deserializedDates = CType(serializer.Deserialize(fs), Date())
    End Using

    ' Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim nItems As Integer
    For Each dat In deserializedDates
        Console.Write($"   {dat:d}     ")
        nItems += 1
        If nItems Mod 5 = 0 Then Console.WriteLine()
    Next
End Sub
' 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

L’exemple précédent n’inclut pas d’informations d’heure. Si une DateTime valeur représente un moment précis et est exprimée sous la forme d’une heure locale, convertissez-la de l’heure locale en heure UTC avant de la sérialiser en appelant la ToUniversalTime méthode. Après l’avoir désérialisé, convertissez-le de l’heure UTC en heure locale en appelant la ToLocalTime méthode. L’exemple suivant utilise la BinaryFormatter classe pour sérialiser des DateTime données sur un système situé dans le fuseau horaire Pacifique (États-Unis) et la désérialiser sur un système situé dans la zone centrale des États-Unis.

public static void PersistBinary()
{
    SaveDatesBinary();
    RestoreDatesBinary();
}

private static void SaveDatesBinary()
{
    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) };
    var fs = new FileStream(filenameBin, FileMode.Create);
    var bin = new BinaryFormatter();

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    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 RestoreDatesBinary()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

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

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    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-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...

Public Sub PersistBinary()
    SaveDatesBinary()
    RestoreDatesBinary()
End Sub

Private Sub SaveDatesBinary()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim fs As New FileStream(filenameBin, FileMode.Create)
    Dim bin As New BinaryFormatter()

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        dates(ctr) = dates(ctr).ToUniversalTime()
    Next
    bin.Serialize(fs, dates)
    fs.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesBinary()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

    Dim fs As New FileStream(filenameBin, FileMode.Open)
    Dim bin As New BinaryFormatter()
    Dim dates As DateTime() = DirectCast(bin.Deserialize(fs), Date())
    fs.Close()

    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToLocalTime().ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' 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-6:00) Central Time (US & Canada)
'       The dates on an en-GB system:
'       14 June 2014 08:32
'       11 July 2014 01:49
'       10 January 2015 03:16
'       20 December 2014 11:45
'       02 June 2014 17:14
'       Restored dates...

Sérialisation des données DateTime et de fuseau horaire

Les exemples précédents supposaient que les DateTime valeurs sont exprimées en tant qu’heures locales. Le code convertit les valeurs entre l’heure UTC et l’heure locale afin qu’elles reflètent le même moment dans le temps sur les systèmes source et cible. DateTime les valeurs peuvent également refléter les moments dans le temps dans un fuseau horaire différent de l’heure locale et de l’heure UTC. Étant donné que la DateTime structure ne prend pas en charge les fuseaux horaires, vous devez sérialiser la DateTime valeur et l' TimeZoneInfo objet qui représente son fuseau horaire. Créez un type dont les champs incluent à la fois la DateTime valeur et son fuseau horaire. L’exemple suivant définit une DateWithTimeZone structure.

using System;

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

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

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

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

Namespace DateTimeExtensions
    <Serializable> Public Structure DateWithTimeZone
        Private tz As TimeZoneInfo
        Private dt As DateTime

        Public Sub New(dateValue As DateTime, timeZone As TimeZoneInfo)
            dt = dateValue
            tz = If(timeZone, TimeZoneInfo.Local)
        End Sub

        Public Property TimeZone As TimeZoneInfo
            Get
                Return tz
            End Get
            Set
                tz = Value
            End Set
        End Property

        Public Property DateTime As Date
            Get
                Return dt
            End Get
            Set
                dt = Value
            End Set
        End Property
    End Structure
End Namespace

Important

La DateWithTimeZone structure est utilisée dans les deux exemples suivants, qui sérialisent et désérialisent un tableau d' DateWithTimeZone objets. vous pouvez afficher la source de la totalité de l’ensemble d’exemples dans cet article, Visual Basic ou C# , dans le référentiel docs sur GitHub.

À l’aide de la DateWithTimeZone structure, vous pouvez alors conserver la date et l’heure, ainsi que les informations de fuseau horaire. L’exemple suivant utilise la BinaryFormatter classe pour sérialiser un tableau d' DateWithTimeZone objets.

public static void SaveDateWithTimeZone()
{
    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")) };
    var fs = new FileStream(@".\Schedule.bin", FileMode.Create);
    var formatter = new BinaryFormatter();
    try
    {
        formatter.Serialize(fs, dates);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Serialization failed. Reason: {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

Public Sub SaveDateWithTimeZone()
    Dim dates As DateWithTimeZone() = {New DateWithTimeZone(#8/9/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/15/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                                  New DateWithTimeZone(#8/22/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/28/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"))}
    Dim fs As New FileStream(".\Schedule.bin", FileMode.Create)
    Dim formatter As New BinaryFormatter()
    Try
        formatter.Serialize(fs, dates)
    Catch e As SerializationException
        Console.WriteLine($"Serialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
    ' Display dates.
    For Each dateInfo In dates
        Dim tz As TimeZoneInfo = dateInfo.TimeZone
        Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
    Next
End Sub
' 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

L’exemple suivant appelle ensuite la BinaryFormatter.Deserialize méthode pour la désérialiser.

public static void RestoreDateWithTimeZone()
{
    const string filename = @".\Schedule.bin";
    FileStream fs;
    if (File.Exists(filename))
    {
        fs = new FileStream(filename, FileMode.Open);
    }
    else
    {
        Console.WriteLine("Unable to find file to deserialize.");
        return;
    }

    var formatter = new BinaryFormatter();
    DateWithTimeZone[] dates;
    try
    {
        dates = (DateWithTimeZone[])formatter.Deserialize(fs);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{ date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Deserialization failed. Reason: {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

Public Sub RestoreDateWithTimeZone()
    Dim fs As FileStream
    If File.Exists(filename) Then
        fs = New FileStream(filename, FileMode.Open)
    Else
        Console.WriteLine("Unable to find file to deserialize.")
        Exit Sub
    End If

    Dim formatter As New BinaryFormatter()
    Dim dates As DateWithTimeZone ()= Nothing
    Try
        dates = DirectCast(formatter.Deserialize(fs), DateWithTimeZone())
        ' Display dates.
        For Each dateInfo In dates
            Dim tz As TimeZoneInfo = dateInfo.TimeZone
            Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
        Next
    Catch e As SerializationException
        Console.WriteLine("Deserialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
End Sub
' 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

DateTime et TimeSpan

Les DateTime TimeSpan types valeur et diffèrent dans ce qui DateTime représente un instant dans le temps, alors que TimeSpan représente un intervalle de temps. Vous pouvez soustraire une instance de d' DateTime une autre pour obtenir un TimeSpan objet qui représente l’intervalle de temps entre eux. Ou vous pouvez ajouter un positif TimeSpan au actuel DateTime pour obtenir une DateTime valeur qui représente une date ultérieure.

Vous pouvez ajouter ou soustraire un intervalle de temps à partir d’un DateTime objet. Les intervalles de temps peuvent être négatifs ou positifs et peuvent être exprimés par des unités telles que des graduations, des secondes ou comme un TimeSpan objet.

Comparaison de l’égalité dans la tolérance

Les comparaisons d’égalité des DateTime valeurs sont exactes. Cela signifie que deux valeurs doivent être exprimées sous la forme d’un nombre de graduations à considérer comme égal. Cette précision est souvent inutile ou même incorrecte pour de nombreuses applications. Souvent, vous souhaitez tester si DateTime les objets sont à peu près égaux.

L’exemple suivant montre comment comparer des valeurs équivalentes à peu près DateTime . Elle accepte une petite marge de différence lorsqu’elle est déclarée comme égale.

public 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 TestRoughlyEquals()
{
    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}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({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

Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

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

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

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

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' 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

Considérations relatives au COM Interop

Une DateTime valeur transférée vers une application com, puis retransférée vers une application managée, est dite aller-retour. Toutefois, une DateTime valeur qui spécifie uniquement une heure n’effectue pas d’aller-retour comme vous pouvez vous y attendre.

Si vous aller-retour uniquement à une heure, par exemple 3 P.M., la date et l’heure finales sont le 30 décembre 1899 (notre ère). à 3:00 h 00 au lieu du 1er janvier 0001 (notre ère) à 3:00 h 00 les .NET Framework et COM supposent une date par défaut lorsque seule une heure est spécifiée. toutefois, le système COM suppose une date de base du 30 décembre 1899 (notre ère), tandis que le .NET Framework suppose une date de base du 1er janvier 0001 (notre ère).

quand seule une heure est passée de l' .NET Framework à COM, un traitement spécial est effectué, qui convertit l’heure au format utilisé par com. quand seule une heure est passée de COM au .NET Framework, aucun traitement spécial n’est effectué car cela corromprait les dates et les heures légitimes au plus tard le 30 décembre 1899. si une date commence son aller-retour à partir de com, les .NET Framework et com conservent la date.

le comportement de l' .NET Framework et de COM signifie que si votre application effectue des allers-retours DateTime qui spécifient uniquement une heure, votre application doit se souvenir de modifier ou d’ignorer la date erronée de l' DateTime objet final.

Constructeurs

DateTime(Int32, Int32, Int32)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois et le jour spécifiés.
DateTime(Int32, Int32, Int32, Calendar)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois et le jour spécifiés pour le calendrier spécifié.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois, le jour, l'heure, la minute et la seconde spécifiés.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois, le jour, l'heure, la minute et la seconde spécifiés pour le calendrier spécifié.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois, le jour, l'heure, la minute, la seconde et l'heure UTC ou locale.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois, le jour, l'heure, la minute, la seconde et la milliseconde spécifiés.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois, le jour, l'heure, la minute, la seconde et la milliseconde spécifiés pour le calendrier spécifié.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois, le jour, l'heure, la minute, la seconde, la milliseconde et l'heure UTC ou locale spécifiés pour le calendrier spécifié.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)	Initialise une nouvelle instance de la structure DateTime avec l'année, le mois, le jour, l'heure, la minute, la seconde, la milliseconde et l'heure UTC ou locale.
DateTime(Int64)	Initialise une nouvelle instance de la structure DateTime avec le nombre de graduations spécifié.
DateTime(Int64, DateTimeKind)	Initialise une nouvelle instance de la structure DateTime avec un nombre spécifié de graduations et une heure UTC ou locale.

Champs

MaxValue	Représente la plus grande valeur possible de DateTime. Ce champ est en lecture seule.
MinValue	Représente la plus petite valeur possible de DateTime. Ce champ est en lecture seule.
UnixEpoch	La valeur de cette constante est équivalente à 00:00:00.0000000 UTC, le 1er janvier 1970, dans le calendrier grégorien. UnixEpoch définit le point dans le temps lorsque l’heure Unix est égale à 0.

Propriétés

Date	Obtient le composant « date » de cette instance.
Day	Obtient le jour du mois représenté par cette instance.
DayOfWeek	Obtient le jour de semaine représenté par cette instance.
DayOfYear	Obtient le jour de l'année représenté par cette instance.
Hour	Obtient le composant « heure » de la date représentée par cette instance.
Kind	Obtient une valeur qui indique si l'heure représentée par cette instance se base sur l'heure locale, l'heure UTC, ou aucune des deux.
Millisecond	Obtient le composant « millisecondes » de la date représentée par cette instance.
Minute	Obtient le composant « minutes » de la date représentée par cette instance.
Month	Obtient le composant « mois » de la date représentée par cette instance.
Now	Obtient un objet DateTime qui a pour valeur la date et l'heure actuelles sur cet ordinateur, exprimées en heure locale.
Second	Obtient le composant « secondes » de la date représentée par cette instance.
Ticks	Obtient le nombre de graduations représentant la date et l'heure de cette instance.
TimeOfDay	Obtient l'heure de cette instance.
Today	Obtient la date actuelle.
UtcNow	Obtient un objet DateTime qui a pour valeur la date et l'heure actuelles sur cet ordinateur, exprimées en temps UTC.
Year	Obtient le composant « année » de la date représentée par cette instance.

Méthodes

Add(TimeSpan)	Retourne un nouveau DateTime qui ajoute la valeur du TimeSpan spécifié à la valeur de cette instance.
AddDays(Double)	Retourne un nouveau DateTime qui ajoute le nombre de jours spécifié à la valeur de cette instance.
AddHours(Double)	Retourne un nouveau DateTime qui ajoute le nombre d'heures spécifié à la valeur de cette instance.
AddMilliseconds(Double)	Retourne un nouveau DateTime qui ajoute le nombre de millisecondes spécifié à la valeur de cette instance.
AddMinutes(Double)	Retourne un nouveau DateTime qui ajoute le nombre de minutes spécifié à la valeur de cette instance.
AddMonths(Int32)	Retourne un nouveau DateTime qui ajoute le nombre de mois spécifié à la valeur de cette instance.
AddSeconds(Double)	Retourne un nouveau DateTime qui ajoute le nombre de secondes spécifié à la valeur de cette instance.
AddTicks(Int64)	Retourne un nouveau DateTime qui ajoute le nombre de graduations spécifié à la valeur de cette instance.
AddYears(Int32)	Retourne un nouveau DateTime qui ajoute le nombre d'années spécifié à la valeur de cette instance.
Compare(DateTime, DateTime)	Compare deux instances de DateTime et retourne un entier qui indique si la première instance est antérieure, identique ou ultérieure à la deuxième instance.
CompareTo(DateTime)	Compare la valeur de cette instance à une valeur DateTime spécifiée et retourne un entier qui indique si cette instance est antérieure, identique ou ultérieure à la valeur DateTime spécifiée.
CompareTo(Object)	Compare la valeur de cette instance à un objet spécifié qui contient une valeur DateTime spécifiée, et retourne un entier qui indique si cette instance est antérieure, identique ou ultérieure à la valeur DateTime spécifiée.
DaysInMonth(Int32, Int32)	Retourne le nombre de jours compris dans le mois et l'année spécifiés.
Equals(DateTime)	Renvoie une valeur indiquant si la valeur de cette instance est égale à la valeur de l'instance DateTime spécifiée.
Equals(DateTime, DateTime)	Retourne une valeur indiquant si deux instances de DateTime représentent la même valeur de date et d'heure.
Equals(Object)	Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.
FromBinary(Int64)	Désérialise une valeur binaire 64 bits et recrée un objet DateTime sérialisé d'origine.
FromFileTime(Int64)	Convertit l'heure de fichier Windows spécifiée en heure locale équivalente.
FromFileTimeUtc(Int64)	Convertit l'heure de fichier Windows spécifiée en heure UTC équivalente.
FromOADate(Double)	Retourne un DateTime qui équivaut à la date OLE Automation spécifiée.
GetDateTimeFormats()	Convertit la valeur de cette instance en toutes les représentations sous forme de chaîne prises en charge par les spécificateurs de format de date et d'heure standard.
GetDateTimeFormats(Char)	Convertit la valeur de cette instance en toutes les représentations sous forme de chaîne prises en charge par le spécificateur de format de date et d'heure standard spécifié.
GetDateTimeFormats(Char, IFormatProvider)	Convertit la valeur de cette instance en toutes les représentations sous forme de chaîne prises en charge par le spécificateur de format de date et d'heure standard spécifié et les données de format propres à la culture.
GetDateTimeFormats(IFormatProvider)	Convertit la valeur de cette instance en toutes les représentations sous forme de chaîne prises en charge par les spécificateurs de format de date et d'heure standard spécifié et les données de format propres à la culture spécifiées.
GetHashCode()	Retourne le code de hachage de cette instance.
GetTypeCode()	Retourne le TypeCode du type valeur DateTime.
IsDaylightSavingTime()	Indique si cette instance de DateTime est dans la plage d'heures d'été pour le fuseau horaire actuel.
IsLeapYear(Int32)	Retourne une indication confirmant si l'année spécifiée est une année bissextile.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convertit une étendue de mémoire contenant la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les informations de format propres à la culture et un style de mise en forme.
Parse(String)	Convertit la représentation sous forme de chaîne d’une date et d’une heure en son DateTime équivalent à l’aide des conventions de la culture actuelle.
Parse(String, IFormatProvider)	Convertit la représentation sous forme de chaîne d'une date et d'une heure en DateTime équivalent à l'aide des informations de format propres à la culture.
Parse(String, IFormatProvider, DateTimeStyles)	Convertit la représentation sous forme de chaîne d’une date/heure en son équivalent DateTime en utilisant les informations de format propres à la culture et un style de mise en forme.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Convertit la représentation sous forme d’étendue spécifiée d’une date et d’une heure en son équivalent DateTime à l’aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié, ou une exception est levée.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Convertit la représentation sous forme d’étendue spécifiée d’une date et d’une heure en son équivalent DateTime à l’aide du tableau de formats ainsi que des informations et du style de format propres à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à au moins l'un des formats spécifiés, ou une exception est levée.
ParseExact(String, String, IFormatProvider)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime à l'aide des informations de format propres à la culture et au format spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en DateTime équivalent à l'aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié, ou une exception est levée.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Convertit la représentation sous forme de chaîne spécifiée d'une date et heure en son équivalent DateTime à l'aide du tableau de formats, des informations et du style de format propres à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement à au moins l'un des formats spécifiés, ou une exception est levée.
SpecifyKind(DateTime, DateTimeKind)	Crée un objet DateTime qui a le même nombre de graduations que le DateTime spécifié, mais qui est désigné comme une heure locale, une heure UTC ou aucune des deux, en fonction de ce que la valeur DateTimeKind spécifiée indique.
Subtract(DateTime)	Retourne un nouveau TimeSpan qui soustrait la date et l’heure spécifiées de la valeur de cette instance.
Subtract(TimeSpan)	Retourne un nouveau DateTime qui soustrait la durée spécifiée de la valeur de cette instance.
ToBinary()	Sérialise l'objet DateTime actuel en une valeur binaire 64 bits qui pourra ensuite être utilisée pour recréer l'objet DateTime.
ToFileTime()	Convertit la valeur de l'objet DateTime actuel en heure de fichier Windows.
ToFileTimeUtc()	Convertit la valeur de l'objet DateTime actuel en heure de fichier Windows.
ToLocalTime()	Convertit la valeur de l'objet DateTime actuel en heure locale.
ToLongDateString()	Convertit la valeur de l'objet DateTime actuel en sa représentation sous forme de chaîne de date longue équivalente.
ToLongTimeString()	Convertit la valeur de l'objet DateTime actuel en sa représentation sous forme de chaîne d'heure longue équivalente.
ToOADate()	Convertit la valeur de cette instance en date OLE Automation équivalente.
ToShortDateString()	Convertit la valeur de l'objet DateTime actuel en sa représentation sous forme de chaîne de date courte équivalente.
ToShortTimeString()	Convertit la valeur de l'objet DateTime actuel en sa représentation sous forme de chaîne d'heure courte équivalente.
ToString()	Convertit la valeur de l’objet DateTime actuel en sa représentation sous forme de chaîne équivalente à l’aide des conventions de mise en forme de la culture actuelle.
ToString(IFormatProvider)	Convertit la valeur de l'objet DateTime actuel en sa représentation sous forme de chaîne équivalente à l'aide des informations de format propres à la culture spécifiées.
ToString(String)	Convertit la valeur de l’objet DateTime actuel en sa représentation sous forme de chaîne équivalente à l’aide du format spécifié et des conventions de mise en forme de la culture actuelle.
ToString(String, IFormatProvider)	Convertit la valeur de l'objet DateTime actuel en sa représentation sous forme de chaîne équivalente à l'aide du format et des informations de format spécifiques à la culture spécifiés.
ToUniversalTime()	Convertit la valeur de l'objet DateTime actuel en Temps universel coordonné (UTC).
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance datetime actuelle dans l’étendue de caractères fournie.
TryParse(ReadOnlySpan<Char>, DateTime)	Convertit l’étendue de caractères spécifiée d’une date et d’une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation sous forme d’étendue d’une date et d’une heure en son équivalent DateTime à l’aide des informations de format et du style de mise en forme propres à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, DateTime)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en son équivalent DateTime à l'aide des informations de format et du style de mise en forme propres à la culture spécifiés, et retourne une valeur qui indique si la conversion a réussi.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation sous forme d’étendue spécifiée d’une date et d’une heure en son équivalent DateTime à l’aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié. La méthode retourne une valeur qui indique si la conversion a réussi.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Convertit l’étendue de caractères spécifiée d’une date et d’une heure en son équivalent DateTime et retourne une valeur qui indique si la conversion a réussi.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation sous forme de chaîne spécifiée d'une date et d'une heure en DateTime équivalent à l'aide des informations et du style de format propres à la culture spécifiés. Le format de la représentation sous forme de chaîne doit correspondre exactement au format spécifié. La méthode retourne une valeur qui indique si la conversion a réussi.
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)	Convertit la représentation sous forme de chaîne spécifiée d'une date et heure en son équivalent DateTime à l'aide du tableau de formats, des informations et du style de format propres à la culture spécifiés. Le format de la chaîne doit correspondre exactement à au moins un des formats spécifiés. La méthode retourne une valeur qui indique si la conversion a réussi.

Opérateurs

Addition(DateTime, TimeSpan)	Ajoute un intervalle de temps spécifié à une date et une heure spécifiées, générant une nouvelle date et heure.
Equality(DateTime, DateTime)	Détermine si deux instances spécifiées de DateTime sont égales.
GreaterThan(DateTime, DateTime)	Détermine si un DateTime spécifié est ultérieur à un autre DateTime spécifié.
GreaterThanOrEqual(DateTime, DateTime)	Détermine si un DateTime spécifié représente une date et une heure identiques ou ultérieures à un autre DateTime spécifié.
Inequality(DateTime, DateTime)	Détermine si deux instances spécifiées de DateTime ne sont pas égales.
LessThan(DateTime, DateTime)	Détermine si un DateTime spécifié est antérieur à un autre DateTime spécifié.
LessThanOrEqual(DateTime, DateTime)	Détermine si un DateTime spécifié représente une date et une heure identiques ou antérieures à un autre DateTime spécifié.
Subtraction(DateTime, DateTime)	Soustrait une date et une heure spécifiées des autres date et heure spécifiées, et retourne un intervalle de temps.
Subtraction(DateTime, TimeSpan)	Soustrait un intervalle de temps spécifié d'une date et d'une heure spécifiées et retourne une nouvelle date et heure.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)	Compare l'instance actuelle à un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position que ce dernier dans l'ordre de tri.
IConvertible.GetTypeCode()	Retourne le TypeCode de cette instance.
IConvertible.ToBoolean(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToChar(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Retourne l'objet DateTime actuel.
IConvertible.ToDecimal(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToInt32(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToInt64(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToSByte(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToSingle(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Convertit l'objet DateTime actuel en objet de type spécifié.
IConvertible.ToUInt16(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToUInt32(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
IConvertible.ToUInt64(IFormatProvider)	Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève une InvalidCastException.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Remplit un objet SerializationInfo des données nécessaires à la sérialisation de l'objet DateTime actuel.

Cohérence de thread

Tous les membres de ce type sont thread-safe. Les membres qui semblent modifier l’état de l’instance retournent en fait une nouvelle instance initialisée avec la nouvelle valeur. Comme pour tout autre type, la lecture et l’écriture dans une variable partagée qui contient une instance de ce type doivent être protégées par un verrou pour garantir la sécurité des threads.

Voir aussi

• DateTimeOffset
• TimeSpan
• Calendar
• GetUtcOffset(DateTime)
• TimeZoneInfo
• Choisir entre DateTime, DateTimeOffset, TimeSpan et TimeZoneInfo
• Utilisation des calendriers
• Exemple : utilitaire de mise en forme .NET Core WinForms (C#)
• Exemple : utilitaire de mise en forme .NET Core WinForms (Visual Basic)