Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Struttura DateTime

 

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

Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere la Reference Source.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

NomeDescrizione
System_CAPS_pubmethodDateTime(Int32, Int32, Int32)

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

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Calendar)

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

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

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

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

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

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

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

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

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

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

System_CAPS_pubmethodDateTime(Int64)

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

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

NomeDescrizione
System_CAPS_pubpropertyDate

Ottiene il componente della data di questa istanza.

System_CAPS_pubpropertyDay

Ottiene il giorno del mese rappresentato da questa istanza.

System_CAPS_pubpropertyDayOfWeek

Ottiene il giorno della settimana rappresentato da questa istanza.

System_CAPS_pubpropertyDayOfYear

Ottiene il giorno dell'anno rappresentato da questa istanza.

System_CAPS_pubpropertyHour

Ottiene il componente relativo all'ora della data rappresentata da questa istanza.

System_CAPS_pubpropertyKind

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

System_CAPS_pubpropertyMillisecond

Ottiene il componente relativo ai millisecondi della data rappresentata da questa istanza.

System_CAPS_pubpropertyMinute

Ottiene il componente relativo ai minuti della data rappresentata da questa istanza.

System_CAPS_pubpropertyMonth

Ottiene il componente relativo al mese della data rappresentata da questa istanza.

System_CAPS_pubpropertySystem_CAPS_staticNow

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

System_CAPS_pubpropertySecond

Ottiene il componente dei secondi della data rappresentata da questa istanza.

System_CAPS_pubpropertyTicks

Ottiene il numero di segni di graduazione che rappresentano la data e l'ora di questa istanza.

System_CAPS_pubpropertyTimeOfDay

Ottiene l'ora del giorno per questa istanza.

System_CAPS_pubpropertySystem_CAPS_staticToday

Ottiene la data corrente.

System_CAPS_pubpropertySystem_CAPS_staticUtcNow

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

System_CAPS_pubpropertyYear

Ottiene il componente dell'anno della data rappresentata da questa istanza.

NomeDescrizione
System_CAPS_pubmethodAdd(TimeSpan)

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

System_CAPS_pubmethodAddDays(Double)

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

System_CAPS_pubmethodAddHours(Double)

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

System_CAPS_pubmethodAddMilliseconds(Double)

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

System_CAPS_pubmethodAddMinutes(Double)

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

System_CAPS_pubmethodAddMonths(Int32)

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

System_CAPS_pubmethodAddSeconds(Double)

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

System_CAPS_pubmethodAddTicks(Int64)

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

System_CAPS_pubmethodAddYears(Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticCompare(DateTime, DateTime)

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

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

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

System_CAPS_pubmethodSystem_CAPS_staticDaysInMonth(Int32, Int32)

Restituisce il numero di giorni nel mese e nell'anno specificati.

System_CAPS_pubmethodEquals(DateTime)

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

System_CAPS_pubmethodSystem_CAPS_staticEquals(DateTime, DateTime)

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

System_CAPS_pubmethodEquals(Object)

Restituisce un valore che indica se questa istanza è uguale ad un oggetto specificato. (Esegue l'override di ValueType.Equals(Object).)

System_CAPS_pubmethodSystem_CAPS_staticFromBinary(Int64)

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

System_CAPS_pubmethodSystem_CAPS_staticFromFileTime(Int64)

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

System_CAPS_pubmethodSystem_CAPS_staticFromFileTimeUtc(Int64)

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

System_CAPS_pubmethodSystem_CAPS_staticFromOADate(Double)

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

System_CAPS_pubmethodGetDateTimeFormats()

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

System_CAPS_pubmethodGetDateTimeFormats(Char)

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

System_CAPS_pubmethodGetDateTimeFormats(Char, IFormatProvider)

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

System_CAPS_pubmethodGetDateTimeFormats(IFormatProvider)

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

System_CAPS_pubmethodGetHashCode()

Restituisce il codice hash per questa istanza. (Esegue l'override di ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_pubmethodGetTypeCode()

Restituisce l'oggetto TypeCode del tipo di valore DateTime.

System_CAPS_pubmethodIsDaylightSavingTime()

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

System_CAPS_pubmethodSystem_CAPS_staticIsLeapYear(Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte la rappresentazione di stringa di una data e di un'ora nell'equivalente DateTime.

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider, DateTimeStyles)

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

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

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

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

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

System_CAPS_pubmethodSubtract(DateTime)

Sottrae la data e l'ora specificate da questa istanza.

System_CAPS_pubmethodSubtract(TimeSpan)

Sottrae la durata specificata da questa istanza.

System_CAPS_pubmethodToBinary()

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

System_CAPS_pubmethodToFileTime()

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

System_CAPS_pubmethodToFileTimeUtc()

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

System_CAPS_pubmethodToLocalTime()

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

System_CAPS_pubmethodToLongDateString()

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

System_CAPS_pubmethodToLongTimeString()

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

System_CAPS_pubmethodToOADate()

Converte il valore di questa istanza nella data di automazione OLE equivalente.

System_CAPS_pubmethodToShortDateString()

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

System_CAPS_pubmethodToShortTimeString()

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

System_CAPS_pubmethodToString()

Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando le convenzioni di formattazione delle impostazioni cultura.(Esegue l'override di ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

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

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

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

System_CAPS_pubmethodToUniversalTime()

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

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

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

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

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

NomeDescrizione
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

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

System_CAPS_pubfieldSystem_CAPS_staticMinValue

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

NomeDescrizione
System_CAPS_puboperatorSystem_CAPS_staticAddition(DateTime, TimeSpan)

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

System_CAPS_puboperatorSystem_CAPS_staticEquality(DateTime, DateTime)

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

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(DateTime, DateTime)

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

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(DateTime, DateTime)

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

System_CAPS_puboperatorSystem_CAPS_staticInequality(DateTime, DateTime)

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

System_CAPS_puboperatorSystem_CAPS_staticLessThan(DateTime, DateTime)

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

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(DateTime, DateTime)

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

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, DateTime)

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

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, TimeSpan)

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

NomeDescrizione
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Restituisce l'attuale oggetto DateTime.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Converte l'oggetto DateTime corrente in un oggetto di un tipo specificato.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

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

System_CAPS_noteNota

Per visualizzare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. È possibile esplorare il codice sorgente online, scaricare i riferimenti per la visualizzazione offline e scorrere le origini (inclusi aggiornamenti e patch) durante l'esecuzione del debug. see instructions.

Il DateTime tipo di valore rappresenta le date e ore con valori compresi tra 00:00:00 (mezzanotte), il 1 ° gennaio, 0001 DC (era cristiana) a 11:59:59 PM, 31 dicembre 9999 D.C. (C.E.) nel calendario gregoriano.

I valori di ora vengono misurati in unità di 100 nanosecondi chiamata segni di graduazione e una determinata data è il numero di tick trascorsi dalla mezzanotte 12:00 del 1 gennaio 0001 D.C. (C.E.) nel GregorianCalendar calendario (esclusi i segni di graduazione che sarebbero aggiunti dai secondi di compensazione). Ad esempio, il valore di segni di graduazione 31241376000000000L rappresenta la data, venerdì, 01 gennaio 0100 mezzanotte (12:00:00). Oggetto DateTime valore è espresso sempre nel contesto di esplicita o calendario predefinito.

System_CAPS_noteNota

Se si lavora con un valore di segni di graduazione che si desidera convertire in altro intervallo di tempo, ad esempio minuti o secondi, è necessario utilizzare il TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, o TimeSpan.TicksPerMillisecond (costante) per eseguire la conversione. Ad esempio, per aggiungere il numero di secondi rappresentato da un numero specificato di tick per le Second componente di un DateTime valore, è possibile utilizzare l'espressione dateValue.Second + nTicks/Timespan.TicksPerSecond.

Contenuto della sezione:

Creazione di un oggetto DateTime
I valori DateTime e le relative rappresentazioni di stringa
Conversione di stringhe in valori DateTime
Considerazioni sulla versione
Valori DateTime
Operazioni di data/ora
Risoluzione di DateTime
Visual Studio di DateTime. TimeSpan
Calendari e i valori DateTime
Persistenza dei valori DateTime
Considerazioni sull'interoperabilità COM

È possibile creare un nuovo DateTime valore di uno dei modi seguenti:

  • Chiamando uno degli overload di DateTime costruttore che consentono di specificare gli elementi specifici del valore di data e ora (ad esempio l'anno, mese e giorno o il numero di tick). L'istruzione seguente viene illustrata una chiamata a uno del DateTime costruttori per creare una data con un anno specifico, mese, giorno, ora, minuto e secondo.

    DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
    
  • Utilizzando la sintassi specifici del compilatore per la dichiarazione di valori di data e ora. Ad esempio, l'istruzione Visual Basic seguente Inizializza una nuova DateTime valore.

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
  • Tramite l'assegnazione di DateTime un valore di data e ora restituito da una proprietà o metodo dell'oggetto. L'esempio seguente assegna la data corrente e ora, data l'ora UTC (Coordinated Universal Time) corrente e ora e la data corrente a tre nuovi DateTime variabili.

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
  • Analizzando la rappresentazione di stringa di un valore di data e ora. Il Parse, ParseExact, TryParse, e TryParseExact tutti i metodi di convertono una stringa per il relativo equivalente valore data e ora. L'esempio seguente usa il Parse per analizzare una stringa e convertirla in un DateTime valore.

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

    Si noti che il TryParse e TryParseExact metodi indicano se una determinata stringa contiene una rappresentazione valida di un DateTime valore oltre a eseguire la conversione.

  • Chiamando il DateTime il costruttore predefinito implicito della struttura. (Per informazioni dettagliate sul costruttore predefinito implicito di un tipo di valore, vedere Tipi di valore (Riferimenti per C#).) Dichiarazione di un equivalente approssimativo, per i compilatori che lo supportano, un DateTime valore senza assegnare in modo esplicito una data e ora a esso. Nell'esempio seguente viene illustrata una chiamata alla DateTime il costruttore predefinito implicito in c# e Visual Basic, nonché una DateTime dichiarazione di variabile senza assegnazione in Visual Basic.

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

Internamente, tutti DateTime i valori sono rappresentati come il numero di tick (il numero di intervalli da 100 nanosecondi) che sono trascorsi dalla mezzanotte 12:00:00 del 1 ° gennaio 0001. L'effettivo DateTime valore è indipendente dalla modalità in cui tale valore viene visualizzato quando visualizzata in un elemento dell'interfaccia utente o scritto in un file. L'aspetto di un DateTime valore è il risultato di un'operazione di formattazione. La formattazione è il processo di conversione di un valore nella relativa rappresentazione di stringa.

Poiché l'aspetto dei valori di data e ora dipende da fattori quali le impostazioni cultura, gli standard internazionali, requisiti dell'applicazione e preferenze personali, la DateTime struttura offre una notevole flessibilità nella formattazione di valori di data e ora tramite gli overload del relativo ToString metodo. Il valore predefinito DateTime.ToString() metodo restituisce la rappresentazione di stringa di un valore di data e ora utilizzando le impostazioni cultura correnti data breve e ora estesa. L'esempio seguente usa il valore predefinito DateTime.ToString() impostazioni cultura per visualizzare la data e ora utilizzando il modello di data breve e ora estesa per en-US, le impostazioni cultura correnti del computer in cui è stato eseguito l'esempio.

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

Il DateTime.ToString(IFormatProvider) metodo restituisce la rappresentazione di stringa di un valore di data e ora di utilizzo di data breve e ora estesa delle impostazioni cultura specifiche. L'esempio seguente usa il DateTime.ToString(IFormatProvider) per visualizzare la data e ora utilizzando il modello di data breve e ora estesa per le impostazioni cultura fr-FR.

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

Il DateTime.ToString(String) metodo restituisce la rappresentazione di stringa di data e ora in un formato definito da un identificatore di formato standard o personalizzato e utilizzando le convenzioni di formattazione delle impostazioni cultura correnti. L'esempio seguente usa il DateTime.ToString(String) metodo per visualizzare la completa modello di data e ora per en-US impostazioni cultura, le impostazioni cultura correnti del computer in cui è stato eseguito l'esempio.

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

La DateTime.ToString(String, IFormatProvider) metodo restituisce la rappresentazione di stringa di data e ora in un formato definito da un identificatore di formato specifico e utilizzando le convenzioni di formattazione delle impostazioni cultura specifiche. Nell'esempio seguente viene utilizzata la DateTime.ToString(String, IFormatProvider) metodo per visualizzare la completo modello di data e ora per le impostazioni cultura fr-FR.

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

Per ulteriori informazioni sulla formattazione DateTime valori, vedere Stringhe di formato di data e ora standard e Stringhe di formato di data e ora personalizzato.

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

  • Rappresentano una data e un'ora che può assumere varie forme e che riflette le convenzioni delle impostazioni di cultura correnti o di impostazioni di cultura specifiche. Ad esempio, un'applicazione può consentire a un utente con le impostazioni cultura corrente sono en-US per immettere un valore di data "15/12/2013" o "15 dicembre 2013", e consentire a un utente cui impostazioni cultura correnti è en-GB a un valore di data di input come "15/12/2013" o "15 dicembre 2013".

  • Rappresentano una data e ora in un formato predefinito. Ad esempio, un'applicazione può serializzare una data come "20130103" indipendentemente dalle impostazioni cultura in cui l'app è in esecuzione o è necessario che una data come input nel formato di data breve della lingua corrente.

È possibile utilizzare il Parse o TryParse metodo per convertire una stringa che può rappresentare uno dei formati comuni di data e ora per impostazioni cultura per un DateTime valore. Nell'esempio seguente viene illustrato come utilizzare TryParse per convertire le stringhe di data in una vasta gamma di formati di specifiche delle impostazioni cultura per un DateTime valore. Modifica le impostazioni cultura correnti per inglese (Regno Unito) e chiama la GetDateTimeFormats() metodo per generare una matrice di stringhe di data e ora. Passa quindi a ogni elemento nella matrice di TryParse metodo. L'output dell'esempio mostra che il metodo di analisi è stata in grado di convertire ogni le specifiche delle impostazioni cultura stringhe data e ora.

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

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

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

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

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

È possibile utilizzare il TryParse e TryParseExact metodi per convertire una stringa di data e ora che deve corrispondere a un particolare formato o formati da un DateTime valore. Specificare il formato richiesto o formati come parametro per l'analisi methodby utilizzando uno o più o stringhe di formato di data e ora. L'esempio seguente usa il TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metodo per convertire le stringhe che devono essere in un formato "aaaammgg" o un formato "HHmmss" DateTime valori.

using System;
using System.Globalization;

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

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

La Parse e ParseExact metodi generano un'eccezione se la stringa da convertire in un DateTime valore non può essere analizzato. Il TryParse e TryParseExact i metodi restituiscono un Boolean valore che indica se la conversione ha avuto esito positivo o negativo. Poiché l'operazione di analisi per le stringhe di data e ora, in particolare se le stringhe di input da parte degli utenti, tenderà ad avere una frequenza elevata di errori, e la gestione delle eccezioni è infatti onerosa, è necessario utilizzare il TryParse o TryParseExact metodi negli scenari in cui le prestazioni sono importanti o conversioni sono soggetti a una frequenza elevata di errore.

Per ulteriori informazioni sull'analisi dei valori di data e ora, vedere Analisi delle stringhe di data e ora in .NET Framework.

Prima di .NET Framework versione 2.0, il DateTime struttura contiene un campo a 64 bit costituito da un campo a 2 bit inutilizzato concatenato con una privata Ticks campo, ovvero un campo a 62 bit senza segno che contiene il numero di tick che rappresentano data e ora. Il valore di Ticks campo può essere ottenuto con la Ticks proprietà.

A partire da .NET Framework 2.0, il DateTime struttura contiene un campo a 64 bit costituito da un campo di tipo privato concatenato con il campo segni di graduazione. Il campo tipo è un campo a 2 bit che indica se la DateTime struttura rappresenta un'ora locale, un'ora UTC (Coordinated Universal Time) o l'ora in un fuso orario non specificato. Il campo tipo viene utilizzato per eseguire le conversioni di ora tra fusi orari, ma non per i confronti di tempo o aritmetico. Il valore del campo tipo può essere ottenuto con la Kind proprietà.

System_CAPS_noteNota

Un'alternativa per il DateTime struttura per l'utilizzo di valori di data e ora in particolare fuso orario è il DateTimeOffset struttura. Il DateTimeOffset struttura archivia le informazioni di data e ora in una privata DateTime campo e il numero di minuti che data e l'ora rispetto all'ora UTC in un privato Int16 campo. Ciò rende possibile un DateTimeOffset valore in modo da riflettere il tempo in un particolare fuso orario, mentre un DateTime valore in modo non ambiguo può riflettere solo l'ora UTC e del fuso orario locale. Per una discussione sull'utilizzo di DateTime struttura o DateTimeOffset struttura quando si lavora con valori di data e ora, vedere Scelta tra DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.

Le descrizioni dei valori ora il DateTime tipo sono spesso espressi mediante lo standard Coordinated Universal Time (UTC), che corrisponde al nome riconosciuto a livello internazionale per ora di Greenwich (GMT). Ora UTC è ora misurata longitudine zero gradi, il punto di origine UTC. L'ora legale non è applicabile in formato UTC.

Ora locale è relativo a un particolare fuso orario. Un fuso orario è associato a una differenza di fuso orario, ovvero lo spostamento del fuso orario, misurato in ore dal punto di origine UTC. Inoltre, ora locale, facoltativamente, è interessata dall'ora legale, che aggiunge o sottrae un'ora dalla durata di un giorno. Di conseguenza, ora locale viene calcolata sommando l'offset del fuso orario UTC e la regolazione dell'ora legale se necessario. La differenza di fuso orario nel punto di origine UTC è zero.

Ora UTC è adatto per i calcoli, confronti e l'archiviazione date e ora nei file. Ora locale è appropriata per la visualizzazione nelle interfacce utente delle applicazioni desktop. Le applicazioni di fuso orario (ad esempio, molte applicazioni Web) devono anche con un numero di altri fusi orari di lavoro.

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

Un calcolo eseguito utilizzando un DateTime struttura, ad esempio Add o Subtract, non modificare il valore della struttura. Al contrario, il calcolo restituisce un nuovo DateTime struttura il cui valore è il risultato del calcolo.

Operazioni di conversione tra fusi orari (ad esempio tra l'ora UTC e l'ora locale, o tra un fuso orario) all'ora legale di prendere in considerazione, ma non eseguire operazioni aritmetiche e di confronto.

Il DateTime struttura stessa offre un supporto limitato per la conversione da un fuso orario a un altro. È possibile utilizzare il ToLocalTime metodo per convertire l'ora UTC in ora locale o si può usare il ToUniversalTime metodo per convertire l'ora locale in ora UTC. È tuttavia disponibile in un set completo di metodi di conversione di fuso orario di TimeZoneInfo classe. Utilizzo di questi metodi, è possibile convertire l'ora in uno dei fusi orari del mondo nell'ora di qualsiasi altro fuso orario.

I calcoli e i confronti di DateTime gli oggetti sono significativi solo se gli oggetti rappresentano orari dello stesso fuso orario. È possibile utilizzare un TimeZoneInfo oggetto per rappresentare un DateTime fuso orario del valore, anche se i due ad accoppiamento debole. (Ovvero, un DateTime oggetto non ha una proprietà che restituisce un oggetto che rappresenta fuso orario il valore data e ora del diverso dal Kind proprietà.) Per questo motivo, in un'applicazione di fuso orario, è necessario basarsi su un meccanismo esterno per determinare il fuso orario in cui un DateTime oggetto è stato creato. Ad esempio, è possibile utilizzare una struttura che esegue il wrapping di entrambe le DateTime valore e TimeZoneInfo oggetto che rappresenta il DateTime fuso orario del valore. Per informazioni dettagliate sull'utilizzo di UTC nei calcoli e i confronti con DateTime valori, vedere Esecuzione di operazioni aritmetiche con date e ore.

Ogni DateTime membro utilizzato in modo implicito il calendario gregoriano per eseguire l'operazione, ad eccezione dei costruttori che specificano un calendario e i metodi con un parametro derivate da IFormatProvider, ad esempio System.Globalization.DateTimeFormatInfo, che specifica in modo implicito un calendario.

Le operazioni con i membri del DateTime tipo prendere in considerazione i dettagli, ad esempio gli anni bisestili e il numero di giorni in un mese.

Due altre operazioni comuni con DateTime valori implicano la conversione di un valore di data e ora in o dalla relativa rappresentazione di stringa. Il processo di conversione di un DateTime valore nella relativa rappresentazione di stringa è un'operazione di formattazione, per ulteriori informazioni sulla formattazione, vedere DateTime valori e le relative rappresentazioni di stringa. Il processo di conversione della rappresentazione di una data e ora per una DateTime valore è un'operazione di analisi, per ulteriori informazioni sull'analisi, vedere conversione di stringhe in valori DateTime.

System_CAPS_noteNota

In alternativa all'esecuzione di una data e ora operazioni aritmetica sul DateTime valori per misurare il tempo trascorso, è possibile utilizzare il Stopwatch classe.

Il Ticks proprietà esprime i valori di data e ora in unità di un decimilionesimo di secondo e Millisecond restituirà i millesimi di secondo in un valore di data e ora. Tuttavia, se si usano chiamate ripetute al DateTime.Now proprietà per misurare il tempo trascorso e si è preoccupati di intervalli di tempo piccola minore di 100 millisecondi, si noti che i valori restituiti dal DateTime.Now proprietà dipendono dal clock di sistema, che nei sistemi Windows 7 e Windows 8 con una risoluzione di circa 15 millisecondi.

Nell'esempio seguente viene illustrata la dipendenza della data corrente e i valori di ora alla risoluzione del clock di sistema. Nell'esempio, un ciclo esterno si ripete 20 volte, e un ciclo interno che consente di ritardare il ciclo esterno. Se il valore del contatore del ciclo esterno è 10, una chiamata al Thread.Sleep metodo introduce un ritardo di cinque millisecondi. Come illustrato nell'output dell'esempio, il numero di millisecondi in restituito dal DateTime.Now.Milliseconds modificare la proprietà solo dopo la chiamata a Thread.Sleep.

using System;
using System.Threading;

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

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

Il DateTime e TimeSpan tipi di valore differiscono in quanto un DateTime rappresenta un istante di tempo, mentre un TimeSpan rappresenta un intervallo di tempo. Ciò significa, ad esempio, che è possibile sottrarre un'istanza di DateTime da un'altra per ottenere un TimeSpan oggetto che rappresenta l'intervallo di tempo tra di essi. Oppure è possibile aggiungere un numero positivo TimeSpan corrente DateTime per ottenere una DateTime valore che rappresenta una data futura.

È possibile aggiungere o sottrarre un intervallo di tempo da un DateTime oggetto. Gli intervalli di tempo può essere positivo o negativo, può essere espressa in unità, ad esempio segni di graduazione o secondi o può essere espresso come un TimeSpan oggetto.

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

Tutte le impostazioni cultura viene utilizzato un calendario predefinito definito per la proprietà di sola lettura CultureInfo.Calendar proprietà e supporta uno o più calendari definiti dal relativo di sola lettura CultureInfo.OptionalCalendars proprietà. Il calendario attualmente utilizzato da uno specifico CultureInfo oggetto è definito dal relativo DateTimeFormatInfo.Calendar proprietà; deve essere uno dei calendari trovati nel CultureInfo.OptionalCalendars matrice.

Calendario corrente delle impostazioni cultura viene utilizzato in tutte le operazioni di formattazione per le impostazioni cultura. Ad esempio, il calendario predefinito delle impostazioni cultura persiano (Iran) è il um al-Qura calendario, in cui è rappresentato dalla UmAlQuraCalendar classe. Quando un CultureInfo oggetto che rappresenta le impostazioni cultura persiano (Iran) viene utilizzato in una data e l'operazione di formattazione dell'ora di um al Qura calendario viene utilizzato per impostazione predefinita e il calendario gregoriano viene utilizzato solo se le impostazioni cultura DateTimeFormatInfo.Calendar proprietà viene modificata, come illustrato nell'esempio seguente.

using System;
using System.Globalization;

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

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

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

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

using System;
using System.Globalization;

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

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

È anche possibile creare un'istanza un DateTime valore utilizzando gli elementi di data e ora (ad esempio il numero dell'anno, mese e giorno) di un calendario specifico chiamando un costruttore DateTime che include un calendar parametro e passando un Calendar oggetto che rappresenta il calendario. Nell'esempio seguente esegue questa usando gli elementi di data e ora dal UmAlQuraCalendar calendario.

using System;
using System.Globalization;

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

DateTimecostruttori che non includono un calendar parametro si presuppone che gli elementi di data e ora sono espressi come unità nel calendario gregoriano.

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

using System;
using System.Globalization;

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

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

Sebbene il DateTime struttura include DayOfWeek proprietà che restituisce il giorno della settimana del calendario gregoriano, non include un membro che consente di recuperare il numero della settimana dell'anno. Per recuperare la settimana dell'anno, chiamare il calendario singoli Calendar.GetWeekOfYear metodo. Nell'esempio seguente viene illustrato questo concetto.

using System;
using System.Globalization;

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

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

Per ulteriori informazioni su date e calendari, vedere Utilizzo di calendari.

È possibile mantenere DateTime i valori in quattro modi:

Indipendentemente dalla tecnica scelto, è necessario assicurarsi che la routine che esegue il ripristino di DateTime valori non perdere dati o generare un'eccezione. DateTimei valori devono round trip. Ovvero, il valore originale e il valore ripristinato deve essere lo stesso. E se originale DateTime valore rappresenta un istante di tempo, è necessario identificare nello stesso momento di tempo quando viene ripristinato.

Per ripristinare correttamente DateTime valori che vengono rese persistenti come stringhe, seguire queste regole:

  • Apportare le stesse ipotesi sulle informazioni di formattazione specifiche delle impostazioni cultura quando si ripristina la stringa come quando si mantenuto. Per garantire che una stringa può essere ripristinata su un sistema le cui impostazioni cultura correnti è diversa dalle impostazioni cultura del sistema in cui è stato salvato, chiamare il ToStringoverload per salvare la stringa usando le convenzioni delle impostazioni cultura invarianti, chiamata di Parse(String, IFormatProvider, DateTimeStyles) o TryParse(String, IFormatProvider, DateTimeStyles, DateTime) overload per ripristinare la stringa usando le convenzioni delle impostazioni cultura invarianti. Non utilizzare mai il ToString(), Parse(String), o TryParse(String, DateTime) overload, che utilizza le convenzioni delle impostazioni cultura del thread corrente.

  • Se i dati rappresentano un singolo istante di tempo, assicurarsi che rappresenta il momento stesso in quando viene ripristinato, anche se viene ripristinato in un sistema che utilizza un fuso orario diverso. A tale scopo, si converte il DateTime valore Coordinated Universal Time (UTC) prima del salvataggio. È anche possibile serializzare il valore insieme a informazioni sul fuso orario; Per ulteriori informazioni, vedere dati DateTime con la serializzazione e il fuso orario.

L'errore più comune eseguita durante il salvataggio DateTime valori come stringhe consiste nell'utilizzare le convenzioni di formattazione predefiniti delle impostazioni cultura correnti. Problemi se le impostazioni cultura correnti sono diversa durante il salvataggio e il ripristino delle stringhe. Nell'esempio seguente vengono illustrati questi problemi. Salva cinque date utilizzando le convenzioni di formattazione delle impostazioni cultura correnti, in questo caso è l'inglese (Stati Uniti). Ripristina le date usando le convenzioni di formattazione delle impostazioni cultura correnti, in questo caso è l'inglese (Regno Unito). Poiché le convenzioni di formattazione delle impostazioni due cultura sono diverse, due delle date non possono essere ripristinati e le date di tre rimanenti vengono interpretate in modo non corretto. Inoltre, se i valori originali di data e ora rappresentano una singole momenti nel tempo, la versione ripristinata volte in cui non sono corrette perché informazioni sul fuso orario viene persi.

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

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

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

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

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

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

Per il round trip DateTime valori correttamente, seguono questi passaggi:

  1. Se i valori rappresentano singoli momenti di tempo, convertirle dall'ora locale in formato UTC chiamando il ToUniversalTime metodo.

  2. Convertire le date nelle rispettive rappresentazioni di stringa chiamando il ToString(String, IFormatProvider) o String.Format(IFormatProvider, String, Object[]) rapporto di overload. Utilizzare le convenzioni di formattazione delle impostazioni cultura invarianti specificando CultureInfo.InvariantCulture come il provider argomento. Specificare che il valore deve essere il round trip mediante il "O" o "R".

  3. Quando si chiama il Parse(String, IFormatProvider, DateTimeStyles) o TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodo.

Per ripristinare la classe resa persistente DateTime valori senza perdita di dati, eseguire le operazioni seguenti:

  1. Analizzare i dati chiamando il ParseExact o TryParseExact rapporto di overload. Specificare CultureInfo.InvariantCulture come il provider argomento e utilizzare lo stesso formato standard di stringa è stato utilizzato per il format argomento durante la conversione. Includere la DateTimeStyles.RoundtripKind valore il styles argomento.

  2. Se il DateTime valori rappresentano singoli momenti, chiamata di ToLocalTime metodo per convertire la data analizzata dall'ora UTC in ora locale.

L'esempio seguente usa le impostazioni cultura invarianti e la stringa di formato standard "O" per garantire che DateTime valori che vengano salvati e ripristinati rappresentano nello stesso momento nel tempo indipendentemente dal sistema, delle impostazioni cultura o fuso orario dei sistemi di origine e destinazione.

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

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

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

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

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

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

Anziché salvare in modo permanente un DateTime valore come stringa, è possibile mantenere come un Int64 valore che rappresenta un numero di segni di graduazione. In questo caso, non è necessario prendere in considerazione le impostazioni cultura dei sistemi di DateTime valori vengono mantenuti e ripristinati su.

Per rendere persistente un DateTime valore come numero intero:

  • Se il DateTime valori rappresentano i momenti singoli, convertirli in formato UTC chiamando il ToUniversalTime metodo.

  • Recuperare il numero di tick rappresentato dal DateTime valore relativo Ticks proprietà.

Per ripristinare un DateTime valore che è stata resa persistente come valore integer:

  1. Creare un'istanza di un nuovo DateTime oggetto passando il Int64 valore per il DateTime(Int64) costruttore.

  2. Se il DateTime valore rappresenta un singolo momento, convertirla rispetto a UTC all'ora locale chiamando il ToLocalTime metodo.

Nell'esempio seguente viene persiste una matrice di DateTime valori come numeri interi in un sistema negli Stati Uniti. fuso orario Pacifico (Stati Uniti). Viene ripristinato in un sistema fuso UTC. Il file che contiene i numeri interi include un Int32 valore che indica il numero totale di Int64 valori che seguono immediatamente.

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

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

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

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

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

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

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

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

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

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

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

Anziché salvare DateTime valori come stringhe o numeri interi, è necessario quindi convertire nuovamente a DateTime valori, è possibile mantenere DateTime valori mediante la serializzazione di un flusso o file e quindi ripristinare tali tramite la deserializzazione. In questo caso, DateTimei dati vengono serializzati in un formato di oggetto specificato e gli oggetti vengono ripristinati quando vengono deserializzati. Un formattatore oppure un serializzatore, ad esempio XmlSerializer o BinaryFormatter, gestisce il processo di serializzazione e deserializzazione. Per ulteriori informazioni sulla serializzazione e i tipi di serializzazione supportato da .NET Framework, vedere Serializzazione.

L'esempio seguente usa il XmlSerializer classe per serializzare e deserializzare DateTime leap di valori che rappresentano tutti i giorni anno il ventunesimo secolo. Se nell'esempio viene eseguito in un sistema le cui impostazioni cultura correnti è inglese (Regno Unito), l'output rappresenta il risultato. Poiché è stato deserializzato il DateTime privo di oggetto, il codice gestire le differenze culturali di formati di data e ora.

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

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

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

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

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

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

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

Nell'esempio precedente non include informazioni sull'ora. Tuttavia, se un DateTime valore rappresenta un istante nel tempo e viene espresso come ora locale, è necessario convertirlo da ora locale in formato UTC prima di serializzarlo chiamando la ToUniversalTime metodo. Dopo la deserializzazione, è necessario convertirlo dall'ora UTC in ora locale chiamando il ToLocalTime metodo. L'esempio seguente usa il BinaryFormatter classe per serializzareDateTime dati in un sistema negli Stati Uniti. Fuso orario ora solare Pacifico e deserializzarlo in un sistema fuso UTC.

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

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

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

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

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

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

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

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

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

Negli esempi precedenti sono tutti presuppone che DateTime valori sono espressi come ore locali e convertire i valori compresi tra l'ora UTC e l'ora locale in modo riflettono nello stesso momento nel tempo nei sistemi di origine e di destinazione. DateTimei valori possono inoltre riflettere momenti in un fuso orario diverso da local e l'ora UTC. In questo caso, poiché il DateTime struttura non è compatibile con fuso orario, è necessario serializzare entrambi il DateTimevalore e TimeZoneInfo oggetto che rappresenta il fuso orario. A tale scopo, creare un tipo i cui campi sono inclusi entrambi i DateTime valore e il fuso orario. L'esempio seguente definisce un DateWithTimeZone struttura in cui viene illustrato come questa operazione può essere eseguita.

using System;

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

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

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

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

Il DateWithTimeZone struttura viene utilizzata negli esempi successivi due cui serializzare e deserializzare una matrice di DateWithTimeZone oggetti. Per eseguire gli esempi, creare innanzitutto una libreria di classi che contiene il DateWithTimeZone struttura e quindi aggiungere un riferimento a esso durante la compilazione di ogni esempio.

Tramite il DateWithTimeZone struttura, è quindi possibile mantenere data e ora insieme a informazioni sul fuso orario. L'esempio seguente usa il BinaryFormatter classe per serializzare una matrice di DateWithTimeZoneoggetti.

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

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

Nell'esempio seguente viene chiamato il BinaryFormatter.Deserialize metodo di deserializzazione.

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

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

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

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

Oggetto DateTime valore viene trasferito a un'applicazione COM e quindi trasferito nuovamente a un'applicazione gestita, viene definito per il round trip. Tuttavia, un DateTime valore che specifica un periodo di tempo non completa il round trip come previsto.

Se è andata solo un'ora, ad esempio le ore 3, la data di scadenza e l'ora è 30 dicembre 1899 D.C. 3:00 P.M., invece, il 1 ° gennaio, 0001 D.C. alle 3:00 Ciò accade perché .NET Framework e COM, si supponga che un valore date predefinito quando viene specificato un periodo di tempo. Tuttavia, il sistema COM si presuppone la data di 30 dicembre 1899 D.C. mentre .NET Framework presuppone una data di base, il 1 ° gennaio, 0001 D.C.

Quando solo una volta che viene passata da .NET Framework a COM, viene eseguita un'elaborazione speciale che converte l'ora nel formato usato da COM. Quando solo una volta che viene passato da COM a .NET Framework, non viene eseguita alcuna elaborazione particolare perché che dovesse danneggiare le date e ore o prima del 30 dicembre 1899. Questo significa anche se una data di inizio il round trip da COM, .NET Framework e COM preservare la data.

Il comportamento di .NET Framework e COM implica che se il round trip applicazione un DateTime specifica solo un periodo di tempo, l'applicazione è necessario ricordarsi di modificare o ignorare la data finale errata DateTime oggetto.

Nell'esempio riportato di seguito viene illustrato come confrontare approssimativamente equivalente DateTime valori, che accetta un piccolo margine di differenza nella dichiarazione di tali uguale.

using System;

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

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

      return Math.Abs(delta) < windowInSeconds;
	}

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

      DateTime d1 = DateTime.Now;

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

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

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

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

Tutti i membri di questo tipo sono thread-safe. I membri che apparentemente modificano lo stato dell'istanza è in realtà restituiscono una nuova istanza inizializzata con il nuovo valore. Come con qualsiasi altro tipo, lettura e scrittura in una variabile condivisa che contiene un'istanza di questo tipo deve essere protetto da un blocco per garantire la thread safety.

System_CAPS_cautionAttenzione

L'assegnazione di un'istanza di questo tipo non è thread-safe in tutte le piattaforme hardware perché la rappresentazione binaria di quell'istanza potrebbe essere troppo grande per assegnare in una singola operazione atomica.

Torna all'inizio
Mostra: