DateTime Struct

Definizione

Rappresenta un istante di tempo, in genere espresso come data e ora del giorno.

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
Ereditarietà
DateTime
Attributi
Implementazioni

Commenti

Importante

Le ere nel calendario giapponese sono basate sul regno dell'imperatore e pertanto è previsto che cambino. Ad esempio, il 1° maggio 2019 contraddistingue l'inizio dell'era Reiwa in JapaneseCalendar e JapaneseLunisolarCalendar. Questo cambio di era interessa tutte le applicazioni che usano questi calendari. Per altre informazioni e per determinare se le applicazioni sono interessate, vedere Gestione di una nuova era nel calendario giapponese in .NET. Per informazioni sul test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento di era, vedere Preparare l'applicazione per la modifica dell'era giapponese. Per le funzionalità in .NET che supportano calendari con più ere e per le procedure consigliate quando si lavora con calendari che supportano più ere, vedere Uso delle ere.

Nota

Alcuni esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.

Il fuso orario locale dello strumento di esecuzione e playground per codice inline Try.NET è Coordinated Universal Time o ora UTC. Ciò può influire sul comportamento e l'output degli esempi che illustrano i tipi DateTime, DateTimeOffset e TimeZoneInfo e i relativi membri.

Questo articolo include diversi esempi che usano il DateTime tipo :

Esempi di inizializzazione

Formattazione DateTime di oggetti come stringhe

Analisi di stringhe come DateTime oggetti

DateTime Risoluzione

Impostazioni cultura e calendari

Persistenza

Questa sezione contiene argomenti per molti usi comuni dello DateTime struct:

Il tipo di valore rappresenta date e ore con valori compresi tra DateTime 00:00:00 (mezzanotte), 1 gennaio 0001 Anno Domini (era comune) e 11:59:59 P.M., 31 dicembre 9999 d.C. (C.E. nel calendario gregoriano).

I valori di tempo vengono misurati in unità di 100 nanosecondi denominate tick. Una data specifica è il numero di tick a partire dalle 12:00 mezzanotte del 1° gennaio 0001 d.C. (C.E.) nel GregorianCalendar calendario. Il numero esclude i tick che verrebbero aggiunti da secondi intercalare. Ad esempio, un valore tick 31241376000000000L rappresenta la data venerdì 01 gennaio 0100 12:00:00 mezzanotte. Un DateTime valore viene sempre espresso nel contesto di un calendario esplicito o predefinito.

Nota

Se si usa un valore tick che si vuole convertire in un altro intervallo di tempo, ad esempio minuti o secondi, è necessario usare la costante , , , o per eseguire la TimeSpan.TicksPerDay TimeSpan.TicksPerHour TimeSpan.TicksPerMinute TimeSpan.TicksPerSecond TimeSpan.TicksPerMillisecond conversione. Ad esempio, per aggiungere il numero di secondi rappresentati da un numero specificato di tick al componente di un valore, è possibile Second DateTime usare l'espressione dateValue.Second + nTicks/Timespan.TicksPerSecond .

È possibile visualizzare l'origine per l'intero set di esempi di questo articolo in Visual Basic o C# dal repository docs in GitHub.

Nota

Un'alternativa alla DateTime struttura per l'utilizzo di valori di data e ora in fusi orari specifici è la DateTimeOffset struttura . La struttura archivia le informazioni di data e ora in un campo privato e il numero di minuti in base al quale la data e l'ora differiscono DateTimeOffset dall'ora UTC in un campo DateTime Int16 privato. Ciò consente a un valore di riflettere l'ora in un fuso orario specifico, mentre un valore può riflettere in modo non ambiguo solo DateTimeOffset DateTime l'ora UTC e l'ora del fuso orario locale. Per informazioni su quando usare la struttura o la struttura quando si usano valori di data e ora, vedere Scelta tra DateTime DateTimeOffset DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.

Inizializzazione di un oggetto DateTime

È possibile assegnare un valore iniziale a un DateTime nuovo valore in molti modi diversi:

  • Chiamare un costruttore, uno in cui si specificano argomenti per i valori o usare il costruttore implicito senza parametri.
  • Assegnazione di un DateTime oggetto al valore restituito di una proprietà o di un metodo.
  • Analisi di un DateTime valore dalla relativa rappresentazione di stringa.
  • Uso Visual Basic specifiche del linguaggio per creare un'istanza di DateTime .

I frammenti di codice seguenti illustrano esempi di ognuno:

Richiamare costruttori

Chiamare uno degli overload del costruttore che specificano gli elementi del valore di data e ora , ad esempio anno, mese e giorno o il DateTime numero di tick. Il codice seguente crea una data specifica usando il DateTime costruttore che specifica anno, mese, giorno, ora, minuto e secondo.

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

Il costruttore implicito senza parametri della struttura viene richiamato quando si vuole inizializzare un oggetto DateTime sul relativo valore DateTime predefinito. Per informazioni dettagliate sul costruttore implicito senza parametri di un tipo di valore, vedere Tipi di valore. Alcuni compilatori supportano anche la dichiarazione di un DateTime valore senza assegnare un valore in modo esplicito. La creazione di un valore senza un'inizializzazione esplicita comporta anche il valore predefinito. L'esempio seguente illustra il costruttore implicito senza parametri in C# e Visual Basic, nonché una dichiarazione senza assegnazione DateTime DateTime in 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));
Assegnazione di un valore calcolato

È possibile assegnare DateTime all'oggetto un valore di data e ora restituito da una proprietà o un metodo. Nell'esempio seguente vengono assegnati la data e l'ora correnti, la data e l'ora Coordinated Universal Time (UTC) e la data corrente a tre nuove DateTime variabili.

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;
Analisi di una stringa che rappresenta un valore DateTime

I Parse metodi , , e ParseExact TryParse TryParseExact convertono tutti una stringa nel valore di data e ora equivalente. Negli esempi seguenti vengono utilizzati Parse i metodi e per analizzare una stringa e ParseExact convertirla in un valore DateTime . Il secondo formato usa un formato supportato dallo standard ISO 8601 per una rappresentazione di data e ora in formato stringa. Questa rappresentazione standard viene spesso usata per trasferire informazioni sulla data nei servizi 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);

I metodi e indicano se una stringa è una rappresentazione valida di un valore e, in caso TryParse TryParseExact DateTime contrario, esegue la conversione.

Sintassi specifica del linguaggio per Visual Basic

L'Visual Basic seguente inizializza un nuovo DateTime valore.

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

Valori DateTime e relative rappresentazioni di stringa

Internamente, tutti i valori sono rappresentati come numero di tick (il numero di intervalli di DateTime 100 nanosecondi) trascorsi dalle 12:00:00 mezzanotte del 1° gennaio 0001. Il valore DateTime effettivo è indipendente dal modo in cui tale valore viene visualizzato quando viene visualizzato. L'aspetto di un valore è il risultato di un'operazione di formattazione DateTime che converte un valore nella relativa rappresentazione di stringa.

L'aspetto dei valori di data e ora dipende dalle impostazioni cultura, gli standard internazionali, i requisiti dell'applicazione e le preferenze personali. La DateTime struttura offre flessibilità nella formattazione dei valori di data e ora tramite overload di ToString . Il metodo predefinito restituisce la rappresentazione di stringa di un valore di data e ora usando il modello di data breve e ora lungo delle impostazioni cultura DateTime.ToString() correnti. Nell'esempio seguente viene utilizzato il metodo DateTime.ToString() predefinito. Visualizza la data e l'ora usando il modello di data breve e ora lunga per le impostazioni cultura correnti. Le impostazioni cultura en-US sono le impostazioni cultura correnti nel computer in cui è stato eseguito l'esempio.

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

Potrebbe essere necessario formattare le date con impostazioni cultura specifiche per supportare scenari Web in cui il server potrebbe avere impostazioni cultura diverse rispetto al client. Specificare le impostazioni cultura usando il metodo per creare la rappresentazione di data breve e ora DateTime.ToString(IFormatProvider) lunga in impostazioni cultura specifiche. Nell'esempio seguente viene utilizzato il metodo per visualizzare la data e l'ora usando il modello di data breve e ora lunga per le impostazioni cultura DateTime.ToString(IFormatProvider) 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

Altre applicazioni possono richiedere rappresentazioni di stringa diverse di una data. Il metodo restituisce la rappresentazione di stringa definita da un identificatore di formato standard o personalizzato usando le convenzioni DateTime.ToString(String) di formattazione delle impostazioni cultura correnti. Nell'esempio seguente viene utilizzato il metodo per visualizzare il modello di data e ora completo per le impostazioni cultura en-US, ovvero le impostazioni cultura correnti nel computer in cui è stato eseguito DateTime.ToString(String) l'esempio.

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

Infine, è possibile specificare le impostazioni cultura e il formato usando il DateTime.ToString(String, IFormatProvider) metodo . Nell'esempio seguente viene utilizzato il metodo per visualizzare il modello di data e DateTime.ToString(String, IFormatProvider) ora completo per le impostazioni cultura 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

DateTime.ToString(String)L'overload può essere usato anche con una stringa di formato personalizzata per specificare altri formati. L'esempio seguente illustra come formattare una stringa usando il formato standard ISO 8601 spesso usato per i servizi Web. Il formato Iso 8601 non ha una stringa di formato standard corrispondente.

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

Per altre informazioni sui valori di formattazione, vedere Stringhe di formato di data e ora DateTime standard e Stringhe di formato di data e ora personalizzate.

Analisi dei valori DateTime dalle stringhe

L'analisi converte la rappresentazione di stringa di una data e di un'ora in un DateTime valore . In genere, le stringhe di data e ora hanno due utilizzi diversi nelle applicazioni:

  • Una data e un'ora accettano diversi formati e riflettono le convenzioni delle impostazioni cultura correnti o di impostazioni cultura specifiche. Ad esempio, un'applicazione consente a un utente le cui impostazioni cultura correnti sono en-US di immettere un valore di data come "15/12/2013" o "15 dicembre 2013". Consente a un utente le cui impostazioni cultura correnti sono en-gb di immettere un valore di data come "15/12/2013" o "15 dicembre 2013".

  • Una data e un'ora sono rappresentate in un formato predefinito. Ad esempio, un'applicazione serializza una data come "20130103" indipendentemente dalle impostazioni cultura in cui è in esecuzione l'app. Un'applicazione può richiedere l'immissione di date nel formato di data breve delle impostazioni cultura correnti.

Usare il metodo o per convertire una stringa da uno dei formati di data e ora comuni usati dalle impostazioni cultura Parse TryParse in un valore DateTime . L'esempio seguente illustra come usare per convertire stringhe di data in formati diversi specifici delle impostazioni TryParse cultura in un valore DateTime . Modifica le impostazioni cultura correnti in inglese (Gran Bretagna) e chiama il metodo per generare una GetDateTimeFormats() matrice di stringhe di data e ora. Passa quindi ogni elemento della matrice al TryParse metodo . L'output dell'esempio mostra che il metodo di analisi è stato in grado di convertire correttamente ognuna delle stringhe di data e ora specifiche delle impostazioni cultura.

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

Usare i metodi e per convertire una stringa che deve corrispondere a uno o più formati ParseExact specifici in un valore TryParseExact DateTime . Una o più stringhe di formato di data e ora vengono specificate come parametro per il metodo di analisi. Nell'esempio seguente viene utilizzato il metodo per convertire in valori le stringhe che devono essere in formato TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) "yyyyMMdd" o "HHmmss". DateTime

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

Un uso comune di per è la conversione di una rappresentazione di stringa da ParseExact un servizio Web, in genere in formato standard ISO 8601. Il codice seguente illustra la stringa di formato corretta da usare:

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}")

Se non è possibile analizzare una stringa, i Parse metodi e ParseExact generano un'eccezione. I TryParse metodi TryParseExact e restituiscono un valore che indica se Boolean la conversione ha avuto esito positivo o negativo. È consigliabile usare TryParse i metodi o negli scenari in cui le prestazioni sono TryParseExact importanti. L'operazione di analisi per le stringhe di data e ora tende ad avere una frequenza di errore elevata e la gestione delle eccezioni è costosa. Usare questi metodi se le stringhe vengono immesse dagli utenti o provenienti da un'origine sconosciuta.

Per altre informazioni sull'analisi dei valori di data e ora, vedere Analisi di stringhe di data e ora.

Valori DateTime

Le descrizioni dei valori di ora nel tipo vengono spesso espresse usando DateTime lo standard Coordinated Universal Time (UTC). Coordinated Universal Time è il nome riconosciuto a livello internazionale per Greenwich Mean Time (GMT). Coordinated Universal Time è l'ora misurata in gradi di longitudine zero, il punto di origine UTC. L'ora legale non è applicabile all'ora UTC.

L'ora locale è relativa a un fuso orario specifico. Un fuso orario è associato a una controparte del fuso orario. Una differenza di fuso orario è lo spostamento del fuso orario misurato in ore dal punto di origine UTC. Inoltre, l'ora locale è facoltativamente interessata dall'ora legale, che aggiunge o sottrae una regolazione dell'intervallo di tempo. L'ora locale viene calcolata aggiungendo la differenza di fuso orario all'ora UTC e regolando l'ora legale, se necessario. L'offset del fuso orario nel punto di origine UTC è zero.

L'ora UTC è adatta per calcoli, confronti e archiviazione di date e ore nei file. L'ora locale è appropriata per la visualizzazione nelle interfacce utente delle applicazioni desktop. Anche le applicazioni in grado di riconoscere il fuso orario, ad esempio molte applicazioni Web, devono usare diversi altri fusi orari.

Se la proprietà di un oggetto è , non viene specificato se l'ora rappresentata è l'ora locale, l'ora UTC o un'ora Kind in un altro fuso DateTime DateTimeKind.Unspecified orario.

Risoluzione di DateTime

Nota

In alternativa all'esecuzione di operazioni aritmetiche di data e ora sui valori per misurare il tempo trascorso, è DateTime possibile usare la classe Stopwatch .

La Ticks proprietà esprime i valori di data e ora in unità di un decimi di secondo. La Millisecond proprietà restituisce i millesimo di secondo in un valore di data e ora. L'uso di chiamate DateTime.Now ripetute alla proprietà per misurare il tempo trascorso dipende dall'orologio di sistema. L'orologio di sistema Windows 7 e Windows 8 ha una risoluzione di circa 15 millisecondi. Questa risoluzione influisce su intervalli di tempo minori di 100 millisecondi.

Nell'esempio seguente viene illustrata la dipendenza dei valori di data e ora correnti dalla risoluzione dell'orologio di sistema. Nell'esempio un ciclo esterno si ripete 20 volte e un ciclo interno serve a ritardare il ciclo esterno. Se il valore del contatore del ciclo esterno è 10, una chiamata al metodo introduce un ritardo Thread.Sleep di cinque millisecondi. Nell'esempio seguente viene illustrato il numero di millisecondi restituiti dalla proprietà solo dopo DateTime.Now.Milliseconds la chiamata a 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

Operazioni DateTime

Un calcolo che DateTime usa una struttura, ad esempio Add o , non modifica il valore della Subtract struttura. Il calcolo restituisce invece una nuova DateTime struttura il cui valore è il risultato del calcolo.

Le operazioni di conversione tra fusi orari (ad esempio tra l'ora UTC e l'ora locale o tra un fuso orario e un altro) prendono in considerazione l'ora legale, ma non le operazioni aritmetiche e di confronto.

La DateTime struttura stessa offre un supporto limitato per la conversione da un fuso orario a un altro. È possibile usare il metodo per convertire l'ora UTC in ora locale oppure il metodo per eseguire la conversione dall'ora locale ToLocalTime ToUniversalTime all'ora UTC. Tuttavia, nella classe è disponibile un set completo di metodi di conversione del fuso TimeZoneInfo orario. È possibile convertire l'ora in uno dei fusi orari del mondo nell'ora in qualsiasi altro fuso orario usando questi metodi.

I calcoli e i confronti degli DateTime oggetti sono significativi solo se gli oggetti rappresentano orari nello stesso fuso orario. È possibile usare un oggetto per rappresentare il fuso orario di un TimeZoneInfo DateTime valore, anche se i due sono in coppia. Un oggetto non dispone di una proprietà che restituisce un oggetto che rappresenta il fuso orario del valore di data DateTime e ora. La Kind proprietà indica se un oggetto rappresenta l'ora UTC, l'ora DateTime locale o non è specificato. In un'applicazione in grado di riconoscere il fuso orario, è necessario basarsi su un meccanismo esterno per determinare il fuso orario in cui è stato DateTime creato un oggetto . È possibile usare una struttura che esegue il wrapping del valore e DateTime TimeZoneInfo dell'oggetto che rappresenta il fuso orario del DateTime valore. Per informazioni dettagliate sull'uso dell'ora UTC nei calcoli e nei confronti con i valori, vedere Esecuzione di operazioni DateTime aritmetiche con date e ore.

Ogni DateTime membro usa in modo implicito il calendario gregoriano per eseguire l'operazione. Le eccezioni sono metodi che specificano in modo implicito un calendario. Sono inclusi i costruttori che specificano un calendario e i metodi con un parametro derivato da IFormatProvider , ad esempio System.Globalization.DateTimeFormatInfo .

Le operazioni eseguite dai membri del tipo prendono in considerazione dettagli quali gli anni DateTime bisestest e il numero di giorni in un mese.

Calendari e valori DateTime

La .NET Framework di classi include una serie di classi di calendario, tutte derivate dalla Calendar classe . Ad esempio:

Importante

Le ere nel calendario giapponese sono basate sul regno dell'imperatore e pertanto è previsto che cambino. Ad esempio, il 1° maggio 2019 contraddistingue l'inizio dell'era Reiwa in JapaneseCalendar e JapaneseLunisolarCalendar. Questo cambio di era interessa tutte le applicazioni che usano questi calendari. Per altre informazioni e per determinare se le applicazioni sono interessate, vedere Gestione di una nuova era nel calendario giapponese in .NET. Per informazioni sul test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento di era, vedere Preparare l'applicazione per la modifica dell'era giapponese. Per le funzionalità in .NET che supportano calendari con più ere e per le procedure consigliate quando si lavora con calendari che supportano più ere, vedere Uso delle ere.

Ogni impostazione cultura usa un calendario predefinito definito dalla relativa proprietà di sola CultureInfo.Calendar lettura. Ogni impostazione cultura può supportare uno o più calendari definiti dalla relativa proprietà di sola CultureInfo.OptionalCalendars lettura. Il calendario attualmente usato da un oggetto CultureInfo specifico è definito dalla relativa proprietà DateTimeFormatInfo.Calendar . Deve essere uno dei calendari presenti nella CultureInfo.OptionalCalendars matrice.

Il calendario corrente delle impostazioni cultura viene usato in tutte le operazioni di formattazione per le impostazioni cultura. Ad esempio, il calendario predefinito delle impostazioni cultura thai-thai era era, che è rappresentato dalla ThaiBuddhistCalendar classe . Quando in un'operazione di formattazione di data e ora viene utilizzato un oggetto che rappresenta le impostazioni cultura thai thai, per impostazione predefinita viene usato il calendario era CultureInfo thai-thai. Il calendario gregoriano viene usato solo se la proprietà delle impostazioni cultura viene DateTimeFormatInfo.Calendar modificata, come illustrato nell'esempio seguente:

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

Il calendario corrente delle impostazioni cultura viene usato anche in tutte le operazioni di analisi per le impostazioni cultura, come illustrato nell'esempio seguente.

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

Creare un'istanza di un valore usando gli elementi di data e ora (numero dell'anno, del mese e del giorno) di un calendario specifico chiamando un costruttore DateTime che include un parametro e passando un oggetto che rappresenta tale DateTime calendar Calendar calendario. Nell'esempio seguente vengono utilizzati gli elementi di data e ora del ThaiBuddhistCalendar calendario.

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 I costruttori che non includono un parametro presuppongono che gli elementi di data e ora siano calendar espressi come unità nel calendario gregoriano.

Tutti gli DateTime altri metodi e proprietà usano il calendario gregoriano. Ad esempio, la proprietà restituisce l'anno nel calendario gregoriano e il metodo presuppone che il parametro sia DateTime.Year un anno nel calendario DateTime.IsLeapYear(Int32) year gregoriano. Ogni DateTime membro che usa il calendario gregoriano ha un membro corrispondente della classe che usa un calendario Calendar specifico. Ad esempio, il metodo restituisce l'anno in un calendario specifico e il metodo interpreta il parametro come numero di anno Calendar.GetYear Calendar.IsLeapYear in un calendario year specifico. Nell'esempio seguente vengono utilizzati DateTime sia i membri e corrispondenti della classe ThaiBuddhistCalendar .

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 struttura include una proprietà che restituisce il giorno della settimana nel calendario DayOfWeek gregoriano. Non include un membro che consente di recuperare il numero di settimana dell'anno. Per recuperare la settimana dell'anno, chiamare il metodo del singolo Calendar.GetWeekOfYear calendario. Nell'esempio seguente viene illustrato questo concetto.

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

Per altre informazioni su date e calendari, vedere Uso dei calendari.

Salvataggio permanente dei valori DateTime

È possibile rendere DateTime persistenti i valori in quattro modi:

È necessario assicurarsi che la routine che ripristina i valori non perda dati o non genera un'eccezione indipendentemente DateTime dalla tecnica scelta. DateTime i valori devono essere round trip. In altri, il valore originale e il valore ripristinato devono essere gli stessi. E se il valore originale rappresenta un singolo istante di tempo, deve identificare lo stesso momento in cui DateTime viene ripristinato.

Salvataggio permanente dei valori come stringhe

Per ripristinare correttamente DateTime i valori persistenti come stringhe, seguire queste regole:

  • Quando si ripristina la stringa come quando è stata mantenuta, si presuppone la stessa formattazione specifica delle impostazioni cultura. Per assicurarsi che una stringa possa essere ripristinata in un sistema le cui impostazioni cultura correnti sono diverse dalle impostazioni cultura del sistema in cui è stata salvata, chiamare l'overload per salvare la stringa usando le convenzioni delle impostazioni cultura ToString invarianti. Chiamare l'overload o per ripristinare la stringa usando le convenzioni delle impostazioni cultura Parse(String, IFormatProvider, DateTimeStyles) TryParse(String, IFormatProvider, DateTimeStyles, DateTime) invarianti. Non usare mai ToString() gli overload , o , che usano le Parse(String) TryParse(String, DateTime) convenzioni delle impostazioni cultura del thread corrente.

  • Se la data rappresenta un singolo momento dell'ora, assicurarsi che rappresenti lo stesso momento in cui viene ripristinata, anche in un fuso orario diverso. Convertire il DateTime valore in Coordinated Universal Time (UTC) prima di salvarlo. È anche possibile serializzare il valore insieme alle informazioni sul fuso orario. Per altre informazioni su questo approccio, vedere Serializing DateTime and time zone data.

L'errore più comune che si verifica quando si rende persistenti i valori come stringhe è fare affidamento sulle convenzioni di formattazione DateTime delle impostazioni cultura predefinite o correnti. Si verificano problemi se le impostazioni cultura correnti sono diverse durante il salvataggio e il ripristino delle stringhe. L'esempio seguente illustra questi problemi. Salva cinque date usando le convenzioni di formattazione delle impostazioni cultura correnti, che in questo caso sono l'inglese (Stati Uniti). Ripristina le date usando le convenzioni di formattazione di impostazioni cultura diverse, che in questo caso sono inglese (Gran Bretagna). Poiché le convenzioni di formattazione delle due impostazioni cultura sono diverse, due delle date non possono essere ripristinate e le tre date rimanenti vengono interpretate in modo non corretto. Inoltre, se i valori di data e ora originali rappresentano singoli momenti nel tempo, le ore ripristinate non sono corrette perché le informazioni sul fuso orario vengono perse.

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

Per eseguire correttamente il round trip DateTime dei valori, seguire questa procedura:

  1. Se i valori rappresentano singoli momenti di tempo, convertirli dall'ora locale all'ora UTC chiamando il ToUniversalTime metodo .
  2. Convertire le date nelle relative rappresentazioni di stringa chiamando ToString(String, IFormatProvider) l'overload o String.Format(IFormatProvider, String, Object[]) . Usare le convenzioni di formattazione delle impostazioni cultura invarianti specificando CultureInfo.InvariantCulture come provider argomento . Specificare che il valore deve eseguire il round trip usando la stringa di formato standard "O" o "R".

Per ripristinare i valori DateTime persistenti senza perdita di dati, seguire questa procedura:

  1. Analizzare i dati chiamando ParseExact l'overload o TryParseExact . Specificare come argomento e usare la stessa stringa di formato standard usata CultureInfo.InvariantCulture provider per format l'argomento durante la conversione. Includere il DateTimeStyles.RoundtripKind valore styles nell'argomento .
  2. Se i valori rappresentano singoli momenti nel tempo, chiamare il metodo per convertire la data DateTime ToLocalTime analizzata dall'ora UTC all'ora locale.

Nell'esempio seguente vengono utilizzate le impostazioni cultura invarianti e la stringa di formato standard "O" per garantire che i valori salvati e ripristinati rappresentino lo stesso momento nel tempo indipendentemente dal sistema, dalle impostazioni cultura o dal fuso orario dei sistemi di origine e di DateTime destinazione.

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...
Salvataggio permanente dei valori come numeri interi

È possibile rendere persistenti una data e un'ora come Int64 valore che rappresenta un numero di tick. In questo caso, non è necessario considerare le impostazioni cultura dei sistemi in cui i valori DateTime vengono resi persistenti e ripristinati.

Per rendere DateTime persistente un valore come numero intero:

  • Se i DateTime valori rappresentano singoli momenti nel tempo, convertirli in formato UTC chiamando il metodo ToUniversalTime .
  • Recuperare il numero di tick rappresentati dal DateTime valore dalla relativa proprietà Ticks .

Per ripristinare DateTime un valore persistente come integer:

  1. Creare DateTime un'istanza di un nuovo oggetto passando il valore al Int64 DateTime(Int64) costruttore.
  2. Se il DateTime valore rappresenta un singolo momento nel tempo, convertirlo dall'ora UTC all'ora locale chiamando il metodo ToLocalTime .

L'esempio seguente rende persistente una matrice di valori come numeri interi in un sistema nel fuso orario del Pacifico degli Stati DateTime Uniti. Lo ripristina in un sistema nella zona UTC. Il file che contiene i numeri interi include un valore che indica il numero totale di valori Int32 Int64 che lo seguono immediatamente.

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

Serializzazione di valori DateTime

È possibile rendere persistenti i valori tramite la serializzazione in un flusso o in un DateTime file e quindi ripristinarli tramite deserializzazione. DateTime i dati vengono serializzati in un formato di oggetto specificato. Gli oggetti vengono ripristinati quando vengono deserializzati. Un formattatore o un serializzatore, ad esempio XmlSerializer o , gestisce il processo di BinaryFormatter serializzazione e deserializzazione. Per altre informazioni sulla serializzazione e sui tipi di serializzazione supportati dal .NET Framework, vedere Serializzazione.

Nell'esempio seguente viene utilizzata XmlSerializer la classe per serializzare e deserializzare DateTime i valori . I valori rappresentano tutti i giorni dell'anno bisestile nel ventunesimo secolo. L'output rappresenta il risultato se l'esempio viene eseguito in un sistema le cui impostazioni cultura correnti sono inglese (Gran Bretagna). Poiché l'oggetto stesso è stato deserializzato, il codice non deve gestire le differenze culturali DateTime nei formati di data e ora.

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'esempio precedente non include informazioni sull'ora. Se un valore rappresenta un momento nel tempo ed è espresso come ora locale, convertirlo dall'ora locale all'ora UTC prima di DateTime serializzarlo chiamando il metodo ToUniversalTime . Dopo la deserializzazione, convertirlo dall'ora UTC all'ora locale chiamando il ToLocalTime metodo . Nell'esempio seguente viene utilizzata la classe per serializzare i dati in un sistema nel fuso orario standard del Pacifico degli Stati Uniti e BinaryFormatter per deserializzarlo in un sistema nella zona Standard centrale degli Stati DateTime Uniti.

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

Serializzazione dei dati DateTime e del fuso orario

Negli esempi precedenti si presuppone che i DateTime valori siano espressi come ora locale. Il codice converte i valori tra l'ora UTC e l'ora locale in modo che riflettano lo stesso momento nel sistema di origine e di destinazione. DateTime I valori possono anche riflettere momenti di tempo in un fuso orario diverso da locale e UTC. Poiché la struttura non supporta il fuso orario, è necessario serializzare sia il valore che l'oggetto DateTime che rappresenta il fuso DateTime TimeZoneInfo orario. Creare un tipo i cui campi includono sia DateTime il valore che il relativo fuso orario. Nell'esempio seguente viene definita una DateWithTimeZone struttura .

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

Importante

La DateWithTimeZone struttura viene usata nei due esempi successivi, che serializzano e deserializzano una matrice di oggetti DateWithTimeZone . È possibile visualizzare l'origine per l'intero set di esempi di questo articolo in Visual Basic o C# dal repository docs in GitHub.

Usando la struttura DateWithTimeZone , è quindi possibile rendere persistenti data e ora insieme alle informazioni sul fuso orario. Nell'esempio seguente viene BinaryFormatter utilizzata la classe per serializzare una matrice di oggetti DateWithTimeZone .

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

Nell'esempio seguente viene quindi chiamato BinaryFormatter.Deserialize il metodo per deserializzarlo.

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

Confronto tra DateTime e TimeSpan

I tipi di valore e sono diversi in base al fatto che DateTime rappresenta un istante nel TimeSpan DateTime tempo, mentre un oggetto rappresenta un TimeSpan intervallo di tempo. È possibile sottrarre un'istanza DateTime di da un'altra per ottenere un TimeSpan oggetto che rappresenta l'intervallo di tempo tra di esse. Oppure è possibile aggiungere un TimeSpan positivo al corrente per ottenere un valore che rappresenta una data DateTime DateTime futura.

È possibile aggiungere o sottrarre un intervallo di tempo da un DateTime oggetto . Gli intervalli di tempo possono essere negativi o positivi e possono essere espressi in unità come tick, secondi o come TimeSpan oggetto.

Confronto per l'uguaglianza all'interno della tolleranza

I confronti di uguaglianza per DateTime i valori sono esatti. Ciò significa che due valori devono essere espressi come lo stesso numero di tick da considerare uguali. Questa precisione è spesso superflua o persino errata per molte applicazioni. Spesso si vuole verificare se gli DateTime oggetti sono approssimativamente uguali.

Nell'esempio seguente viene illustrato come confrontare valori approssimativamente DateTime equivalenti. Accetta un piccolo margine di differenza quando vengono dichiarati uguali.

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

Considerazioni sull'interoperabilità COM

Un DateTime valore che viene trasferito a un'applicazione COM, quindi viene trasferito nuovamente a un'applicazione gestita, viene detto round trip. Tuttavia, un DateTime valore che specifica solo un'ora non esegue il round trip come previsto.

Se si arrotonda solo un'ora, ad esempio le 15,00, la data e l'ora finali sono il 30 dicembre 1899 C.E. alle 15:00 invece dell'1 gennaio 0001 C.E. alle 15:00 I .NET Framework com presuppongono una data predefinita quando viene specificata solo un'ora. Tuttavia, il sistema COM presuppone una data di base del 30 dicembre 1899 C.E., mentre il .NET Framework presuppone una data di base del 1° gennaio 0001 C.E.

Quando viene passato solo un tempo dal .NET Framework a COM, viene eseguita un'elaborazione speciale che converte l'ora nel formato usato da COM. Quando viene passata solo un'ora da COM al .NET Framework, non viene eseguita alcuna elaborazione speciale perché ciò potrebbe danneggiare le date e le ore legittime il 30 dicembre 1899 o prima del 30 dicembre 1899. Se una data inizia il round trip da COM, .NET Framework e COM mantengono la data.

Il comportamento di .NET Framework e COM significa che se l'applicazione arrotonda un oggetto che specifica solo un'ora, l'applicazione deve ricordarsi di modificare o ignorare la data errata dell'oggetto DateTime DateTime finale.

Costruttori

DateTime(Int32, Int32, Int32)

Inizializza una nuova istanza della struttura DateTime su anno, mese e giorno specificati.

DateTime(Int32, Int32, Int32, Calendar)

Inizializza una nuova istanza della struttura DateTime su anno, mese e giorno indicati per il calendario specificato.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto e secondo specificati.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto e secondo determinati per il calendario specificato.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo e ora UTC (Coordinated Universal Time) oppure ora locale specificati.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo e millisecondo specificati.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo e millisecondo determinati per il calendario specificato.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo, millisecondo e ora UTC (Coordinated Universal Time) oppure ora locale specificati per il calendario indicato.

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo, millisecondo e ora UTC (Coordinated Universal Time) oppure ora locale specificati.

DateTime(Int64)

Inizializza una nuova istanza della struttura DateTime su un numero di tick specificato.

DateTime(Int64, DateTimeKind)

Inizializza una nuova istanza della struttura DateTime su un numero specificato di tick e sull'ora UTC (Coordinated Universal Time) oppure sull'ora locale.

Campi

MaxValue

Rappresenta il valore massimo possibile di DateTime. Questo campo è di sola lettura.

MinValue

Rappresenta il valore più piccolo possibile di DateTime. Questo campo è di sola lettura.

UnixEpoch

Il valore di questa costante è equivalente a 00:00:00.0000000 UTC, 1 gennaio 1970, nel calendario gregoriano. UnixEpoch definisce il momento in cui l'ora UNIX è uguale a 0.

Proprietà

Date

Ottiene il componente di data dell'istanza.

Day

Ottiene il giorno del mese rappresentato dall'istanza.

DayOfWeek

Ottiene il giorno della settimana rappresentato dall'istanza.

DayOfYear

Ottiene il giorno dell'anno rappresentato dall'istanza.

Hour

Ottiene il componente di ora della data rappresentata dall'istanza.

Kind

Ottiene un valore che indica se l'ora rappresentata dall'istanza si basa sull'ora locale, sull'ora UTC (Coordinated Universal Time) o su nessuna delle due.

Millisecond

Ottiene il componente di millisecondi della data rappresentata dall'istanza.

Minute

Ottiene il componente di minuti della data rappresentata dall'istanza.

Month

Ottiene il componente di mese della data rappresentata dall'istanza.

Now

Ottiene un oggetto DateTime impostato su data e ora correnti sul computer, espresso come ora locale.

Second

Ottiene il componente di secondi della data rappresentata dall'istanza.

Ticks

Ottiene il numero di tick che rappresentano data e ora dell'istanza.

TimeOfDay

Ottiene l'ora del giorno per l'istanza.

Today

Ottiene la data corrente.

UtcNow

Ottiene un oggetto DateTime impostato su data e ora correnti sul computer, espresso come ora UTC (Coordinated Universal Time).

Year

Ottiene il componente dell'anno della data rappresentata dall'istanza.

Metodi

Add(TimeSpan)

Restituisce un nuovo oggetto DateTime che aggiunge il valore dell'oggetto TimeSpan specificato al valore di questa istanza.

AddDays(Double)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di giorni al valore di questa istanza.

AddHours(Double)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di ore al valore di questa istanza.

AddMilliseconds(Double)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di millisecondi al valore di questa istanza.

AddMinutes(Double)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di minuti al valore di questa istanza.

AddMonths(Int32)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di mesi al valore di questa istanza.

AddSeconds(Double)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di secondi al valore di questa istanza.

AddTicks(Int64)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di tick al valore di questa istanza.

AddYears(Int32)

Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di anni al valore di questa istanza.

Compare(DateTime, DateTime)

Confronta due istanze di DateTime e restituisce un intero che indica se la prima istanza è precedente, uguale o successiva alla seconda istanza.

CompareTo(DateTime)

Confronta il valore di questa istanza con un valore DateTime specificato e restituisce un intero che indica se l'istanza è precedente, uguale o successiva al valore DateTime specificato.

CompareTo(Object)

Confronta il valore di questa istanza con un oggetto specificato contenente un valore DateTime specificato e restituisce un intero che indica se l'istanza è precedente, uguale o successiva al valore DateTime specificato.

DaysInMonth(Int32, Int32)

Restituisce il numero di giorni del mese specificato dell'anno specificato.

Equals(DateTime)

Restituisce un valore che indica se il valore di questa istanza è uguale al valore dell'istanza di DateTime specificata.

Equals(DateTime, DateTime)

Restituisce un valore che indica se due istanze di DateTime presentano lo stesso valore di data e ora.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.

FromBinary(Int64)

Deserializza un valore binario a 64 bit e ricrea un oggetto originale DateTime serializzato.

FromFileTime(Int64)

Converte l'ora specificata di un file di Windows in un'ora locale equivalente.

FromFileTimeUtc(Int64)

Converte l'ora di un file di Windows specificata in un'ora UTC equivalente.

FromOADate(Double)

Restituisce un oggetto DateTime equivalente alla data di automazione OLE specificata.

GetDateTimeFormats()

Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dagli identificatori di formato di data e ora standard.

GetDateTimeFormats(Char)

Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dall'identificatore di formato di data e ora standard specificato.

GetDateTimeFormats(Char, IFormatProvider)

Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dall'identificatore di formato di data e ora standard e dalle informazioni di formattazione specifiche delle impostazioni cultura.

GetDateTimeFormats(IFormatProvider)

Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dagli identificatori di formato di data e ora standard e dalle informazioni di formattazione relative alle impostazioni cultura specificate.

GetHashCode()

Restituisce il codice hash per l'istanza.

GetTypeCode()

Restituisce l'oggetto TypeCode del tipo di valore DateTime.

IsDaylightSavingTime()

Indica se l'istanza dell'oggetto DateTime è compresa nell'intervallo l'ora legale del fuso orario corrente.

IsLeapYear(Int32)

Restituisce un'indicazione che informa se l'anno specificato è bisestile.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Converte un intervallo di memoria che contiene la rappresentazione stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione.

Parse(String)

Converte la rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le convenzioni delle impostazioni cultura del thread corrente.

Parse(String, IFormatProvider)

Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo DateTime equivalente usando le informazioni sul formato relative alle impostazioni cultura specificate.

Parse(String, IFormatProvider, DateTimeStyles)

Converte la rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione.

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice specificata di formati, informazioni sul formato specifiche delle impostazioni cultura e stile. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione.

ParseExact(String, String, IFormatProvider)

Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo oggetto DateTime equivalente usando il formato specificato e le informazioni sul formato relative alle impostazioni cultura specificate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione.

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

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione.

SpecifyKind(DateTime, DateTimeKind)

Crea un nuovo oggetto DateTime che ha lo stesso numero di tick dell'oggetto DateTime specificato, ma viene definito come ora locale, ora UTC (Coordinated Universal Time) o nessuna delle due, a seconda di quanto indicato nel valore di DateTimeKind specificato.

Subtract(DateTime)

Restituisce un nuovo elemento TimeSpan che sottrae la data e l'ora specificate dal valore dell'istanza.

Subtract(TimeSpan)

Restituisce un nuovo elemento DateTime che sottrae la durata specificata dal valore dell'istanza.

ToBinary()

Serializza l'oggetto DateTime corrente in un valore binario a 64 bit che può essere quindi usato per ricreare l'oggetto DateTime.

ToFileTime()

Converte il valore dell'oggetto DateTime corrente in un'ora di un file di Windows.

ToFileTimeUtc()

Converte il valore dell'oggetto DateTime corrente in un'ora di un file di Windows.

ToLocalTime()

Converte il valore dell'oggetto DateTime corrente in un'ora locale.

ToLongDateString()

Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa della data estesa.

ToLongTimeString()

Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa dell'ora estesa.

ToOADate()

Converte il valore dell'istanza nella data di automazione OLE equivalente.

ToShortDateString()

Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa della data breve.

ToShortTimeString()

Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa dell'ora breve.

ToString()

Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando le convenzioni di formattazione delle impostazioni cultura.

ToString(IFormatProvider)

Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando le informazioni sul formato relative alle impostazioni cultura specificate.

ToString(String)

Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando il formato specificato e le convenzioni di formattazione delle impostazioni cultura.

ToString(String, IFormatProvider)

Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando il formato specificato e le informazioni sul formato specifiche delle impostazioni cultura indicate.

ToUniversalTime()

Converte il valore dell'oggetto DateTime corrente nell'ora UTC (Coordinated Universal Time).

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tenta di formattare il valore dell'istanza datetime corrente nell'intervallo di caratteri specificato.

TryParse(ReadOnlySpan<Char>, DateTime)

Converte l'intervallo di caratteri specificato di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Converte una rappresentazione in forma di intervallo di una data e di un'ora nell'equivalente DateTime usando le informazioni sul formato specifico delle impostazioni cultura e lo stile di formattazione specifici, quindi restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParse(String, DateTime)

Converte la rappresentazione di stringa specificata di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'equivalente DateTime usando le informazioni sul formato specifico delle impostazioni cultura e lo stile di formattazione specifici, quindi restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)

Converte l'intervallo di caratteri specificato di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

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

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

Operatori

Addition(DateTime, TimeSpan)

Aggiunge un determinato intervallo di tempo a una data e a un'ora specificate, producendo una data e un'ora nuove.

Equality(DateTime, DateTime)

Determina se due istanze specificate dell'oggetto DateTime sono uguali.

GreaterThan(DateTime, DateTime)

Determina se un DateTime specificato è successivo a un altro DateTime specificato.

GreaterThanOrEqual(DateTime, DateTime)

Determina se un oggetto DateTime specificato rappresenta una data e ora uguali o successive a un altro oggetto DateTime specificato.

Inequality(DateTime, DateTime)

Determina se due istanze specificate dell'oggetto DateTime non sono uguali.

LessThan(DateTime, DateTime)

Determina se un oggetto DateTime specificato è precedente a un altro oggetto DateTime specificato.

LessThanOrEqual(DateTime, DateTime)

Determina se un oggetto DateTime specificato rappresenta una data e ora uguali o precedenti a un altro oggetto DateTime specificato.

Subtraction(DateTime, DateTime)

Sottrae una data e un'ora specificate da un'altra data e un'altra ora specificate e restituisce un intervallo di tempo.

Subtraction(DateTime, TimeSpan)

Sottrae un intervallo di tempo specificato da una data e un'ora specificate e restituisce una data e un'ora nuove.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)

Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.

IConvertible.GetTypeCode()

Restituisce l'oggetto TypeCode per questa istanza.

IConvertible.ToBoolean(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToByte(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToChar(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

Restituisce l'attuale oggetto DateTime.

IConvertible.ToDecimal(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToDouble(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToInt16(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToInt32(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToInt64(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToSByte(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToSingle(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToType(Type, IFormatProvider)

Converte l'oggetto DateTime corrente in un oggetto di un tipo specificato.

IConvertible.ToUInt16(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToUInt32(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

IConvertible.ToUInt64(IFormatProvider)

Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Compila un oggetto SerializationInfo con i dati necessari per serializzare l'oggetto DateTime corrente.

Si applica a

Thread safety

Tutti i membri di questo tipo sono thread-safe. I membri che sembrano modificare lo stato dell'istanza restituiscono effettivamente una nuova istanza inizializzata con il nuovo valore. Come per qualsiasi altro tipo, la lettura e la scrittura in una variabile condivisa che contiene un'istanza di questo tipo devono essere protette da un blocco per garantire la thread safety.

Vedi anche