Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Esporta (0) Stampa
Espandi tutto

Struttura DateTime

Aggiornamento: Luglio 2008

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

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

[SerializableAttribute]
public struct DateTime : IComparable, IFormattable, 
	IConvertible, ISerializable, IComparable<DateTime>, IEquatable<DateTime>
/** @attribute SerializableAttribute */ 
public final class DateTime extends ValueType implements IComparable, 
	IFormattable, IConvertible, ISerializable, IComparable<DateTime>, 
	IEquatable<DateTime>
JScript supporta l'utilizzo di strutture ma non la dichiarazione di nuove.

Il tipo di valore DateTime rappresenta i valori di data e ora compresi tra le ore 00.00.00 del 1° gennaio 0001 D.C. e le ore 23.59.59 del 31 dicembre 9999 D.C.

I valori di ora vengono misurati in unità di 100 nanosecondi, definite segni di graduazione. Una determinata data è rappresentata dal numero di segni di graduazione a partire dalle ore 00.00 del 1° gennaio 0001 D.C. del calendario GregorianCalendar. Un valore di segni di graduazione di 31241376000000000L rappresenta, ad esempio, la data venerdì 1° gennaio dell'anno 100, ore 00.00.00. Un valore DateTime viene sempre espresso nel contesto di un calendario predefinito o esplicito.

Creazione di un'istanza di un oggetto DateTime

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

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

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

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
    
    
  • Assegnando all'oggetto DateTime un valore di data e ora restituito da una proprietà o un metodo. Nell'esempio seguente vengono assegnate la data e l'ora correnti, la data e l'ora UTC (Coordinated Universal Time) correnti e la data corrente a tre nuove variabili DateTime.

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
    
    
  • Analizzando la rappresentazione di stringa di un valore di data e ora. I metodi Parse, ParseExact, TryParse e TryParseExact convertono una stringa nel valore di data e ora equivalente. Nell'esempio seguente viene utilizzato il metodo Parse per analizzare una stringa e convertirla in un valore DateTime.

    string dateString = "5/1/2008 8:30:52 AM";
    DateTime date1 = DateTime.Parse(dateString, CultureInfo.InvariantCulture); 
    
    
    
  • Chiamando il costruttore predefinito implicito della struttura DateTime. Per i dettagli sul costruttore predefinito implicito di un tipo valore, vedere Tipi di valore (Riferimenti per C#). Un equivalente approssimativo, per i compilatori che lo supportano, è dato dalla dichiarazione di un valore DateTime senza assegnazione esplicita di una data e un'ora. Nell'esempio seguente viene illustrata una chiamata al costruttore predefinito implicito di DateTime in C# e Visual Basic, oltre a una dichiarazione della variabile DateTime 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(CultureInfo.InvariantCulture));
    // The following method call displays True.
    Console.WriteLine(dat1.Equals(DateTime.MinValue));
    
    
    

Valori DateTime e relative rappresentazioni di stringa

A livello interno, tutti i valori DateTime vengono rappresentati come numero di tick (intervalli di 100 nanosecondi) trascorsi dalle ore 00.00.00 del 1° gennaio 0001. Il valore DateTime effettivo è indipendente dall'aspetto assunto quando visualizzato in un elemento dell'interfaccia utente o scritto in un file. L'aspetto di un valore DateTime è il risultato di un'operazione di formattazione, vale a dire di conversione del valore nella relativa rappresentazione di stringa.

Dal momento che l'aspetto dei valori di data e ora dipende da fattori quali le impostazioni cultura, gli standard internazionali, i requisiti dell'applicazione e le preferenze personali, la struttura DateTime consente una grande flessibilità nella formattazione dei valori di data e ora tramite gli overload del metodo ToString. Il metodo DateTime.ToString() predefinito restituisce la rappresentazione di stringa di un valore di data e ora utilizzando il modello di data breve e ora estesa delle impostazioni cultura correnti. Nell'esempio seguente viene utilizzato il metodo DateTime.ToString() predefinito per visualizzare la data e l'ora utilizzando il modello di data breve e ora estesa delle impostazioni cultura en-US, ovvero le impostazioni cultura correnti del computer sul quale è 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 metodo DateTime.ToString(IFormatProvider) restituisce la rappresentazione di stringa di un valore di data e ora utilizzando il modello di data breve e ora estesa di impostazioni cultura specifiche. Nell'esempio seguente viene utilizzato il metodo DateTime.ToString(IFormatProvider) per visualizzare la data e l'ora utilizzando il modello di data breve e ora estesa delle impostazioni cultura fr-FR.

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


Il metodo DateTime.ToString(String) 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. Nell'esempio seguente viene utilizzato il metodo DateTime.ToString(String) per visualizzare il modello di data e ora completo delle impostazioni cultura en-US, ovvero le impostazioni cultura correnti del computer sul quale è 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


Il metodo DateTime.ToString(String, IFormatProvider) 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 di impostazioni cultura specifiche. Nell'esempio seguente viene utilizzato il metodo DateTime.ToString(String, IFormatProvider) per visualizzare il modello di data e ora completo delle impostazioni cultura fr-FR.

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


Considerazioni sulle versioni

Nelle versioni di .NET Framework precedenti alla 2.0, la struttura DateTime contiene un campo a 64 bit composto da un campo a 2 bit inutilizzato concatenato a un campo Segni di graduazione privato, ovvero un campo a 62 bit senza segno che contiene il numero di segni di graduazione che rappresentano la data e l'ora. Per ottenere il valore del campo Segni di graduazione è possibile utilizzare la proprietà Ticks.

A partire dalla versione 2.0 di .NET Framework, la struttura DateTime contiene un campo a 64 bit composto da un campo Tipo privato concatenato al campo Segni di graduazione. Il campo Tipo è un campo a 2 bit in cui viene indicato se la struttura DateTime rappresenta un'ora locale, un'ora UTC (Coordinated Universal Time) o l'ora in un fuso orario non specificato. Tale campo viene utilizzato per eseguire conversioni dell'ora tra fusi orari, ma non per confronti tra ore o per operazioni aritmetiche. Per ottenere il valore del campo Tipo è possibile utilizzare la proprietà Kind.

03ybds8y.alert_note(it-it,VS.90).gifNota:

In alternativa alla struttura DateTime per lavorare con valori di data e ora in fusi orari particolari è possibile utilizzare la struttura DateTimeOffset. La struttura DateTimeOffset archivia le informazioni su data e ora in un campo DateTime privato, mentre il numero di minuti di differenza tra tale data e ora e l'ora UTC viene archiviato in un campo Int16 privato. Tale accorgimento consente a un valore DateTimeOffset di riflettere l'ora in un particolare fuso orario, mentre un valore DateTime potrà riflettere inequivocabilmente soltanto l'ora UTC e l'ora del fuso orario locale. Per una discussione circa l'utilizzo della struttura DateTime piuttosto che della struttura DateTimeOffset quando si lavora con valori di data e ora, vedere Scelta tra DateTime, DateTimeOffset e TimeZoneInfo.

Valori delle strutture DateTime

Le descrizioni dei valori di ora nel tipo DateTime vengono spesso espresse utilizzando lo standard UTC (Coordinated Universal Time), noto a livello internazionale come ora di Greenwich (GMT, Greenwich Mean Time). Lo standard UTC definisce l'ora misurata rispetto a un punto di riferimento posto a una longitudine di zero gradi. All'ora UTC non è applicabile l'ora legale.

L'ora locale è relativa a un fuso orario specifico. Un fuso orario è associato a una differenza di fuso orario, ovvero allo scostamento del fuso orario dal punto di riferimento dello standard UTC misurato in ore. Inoltre, l'ora locale è eventualmente influenzata dall'ora legale, che aggiunge o sottrae un'ora dalla durata di una giornata. Pertanto, l'ora locale è calcolata aggiungendo la differenza di fuso orario all'ora UTC e, se necessario, applicando il fattore dovuto all'ora legale. La differenza di fuso orario nel punto di riferimento dello standard UTC è zero.

L'ora UTC è ideale per l'esecuzione di calcoli e confronti e per la memorizzazione di date e orari nei file. L'ora locale, invece, risulta essere più adatta nelle interfacce utente delle applicazioni desktop. Le applicazioni che dipendono dal fuso orario, ad esempio molte applicazioni Web, necessitano di lavorare anche con fusi orari diversi.

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

Operazioni sulle strutture DateTime

I calcoli effettuati sulle strutture DateTime, ad esempio mediante i metodi Add o Subtract, non modificano i valori delle strutture. I calcoli di questo tipo, invece, restituiscono una nuova struttura DateTime il cui valore è il risultato del calcolo stesso.

Le operazioni di conversione tra fusi orari, ad esempio tra ora UTC e ora locale, o tra un fuso orario e un altro, prendono in considerazione l'ora legale, al contrario di quanto accade per le operazioni aritmetiche e di confronto.

La struttura DateTime in sé offre un supporto limitato per la conversione da un fuso orario a un altro. È possibile utilizzare il metodo ToLocalTime per convertire l'ora UTC in ora locale, oppure il metodo ToUniversalTime per convertire l'ora locale in ora UTC. In ogni caso, un insieme completo di metodi di conversione dei fusi orari è disponibile nella classe TimeZoneInfo. Tramite questi metodi, è possibile convertire l'ora di un qualsiasi fuso orario nel mondo nell'ora di un fuso orario diverso.

I calcoli e i confronti fra oggetti DateTime sono significativi solo se tali oggetti rappresentano orari del medesimo fuso orario. È possibile utilizzare un oggetto TimeZoneInfo per rappresentare un fuso orario del valore DateTime, benché i due non siano strettamente collegati. Vale a dire, un oggetto DateTime non possiede alcuna proprietà che restituisca un oggetto rappresentante il fuso orario di quel valore di data e ora, se non la proprietà Kind. Per questo motivo, in un'applicazione che dipende dal fuso orario, è necessario basarsi su un meccanismo esterno per determinare il fuso orario nel quale un oggetto DateTime è stato creato. Ad esempio, è possibile utilizzare una struttura che esegue il wrapping sia del valore DateTime che dell'oggetto TimeZoneInfo rappresentante il fuso orario del valore DateTime. Per i dettagli sull'utilizzo del formato UTC nei calcoli e nei confronti con i valori DateTime, vedere Esecuzione di operazioni aritmetiche con date e ore.

Per eseguire le proprie operazioni, i membri della struttura DateTime utilizzano in modo implicito il calendario gregoriano, ad eccezione dei costruttori che specificano un calendario e dei metodi che dispongono di un parametro derivato da un'interfaccia IFormatProvider, quale ad esempio System.Globalization.DateTimeFormatInfo, che specifica implicitamente un calendario.

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

Confronto fra gli oggetti DateTime e TimeSpan

I tipi di valore DateTime e TimeSpan differiscono poiché DateTime rappresenta un istante di tempo, mentre TimeSpan rappresenta un intervallo di tempo. Ciò significa, ad esempio, che è possibile sottrarre un'istanza di DateTime da un'altra istanza per ottenere un oggetto TimeSpan rappresentante l'intervallo di tempo compreso fra le due. Oppure è possibile aggiungere un oggetto TimeSpan positivo all'oggetto DateTime corrente per ottenere un valore DateTime che rappresenta una data futura.

A un oggetto DateTime è possibile aggiungere o sottrarre un intervallo di tempo. Gli intervalli di tempo possono essere negativi o positivi, possono essere espressi in unità, ad esempio segni di graduazione o secondi, oppure come un oggetto TimeSpan.

Considerazioni sull'interoperabilità COM

Una sequenza di andata e ritorno si ha quando il valore di un oggetto DateTime viene prima trasferito a un'applicazione COM e quindi trasferito nuovamente a un'applicazione gestita. Tuttavia, contrariamente a quanto si possa pensare, ciò non accade se il valore dell'oggetto DateTime specifica soltanto un orario.

Se si esegue il percorso di andata e ritorno solo dell'ora, ad esempio le 15.00, la data e l'ora finale saranno 30 dicembre 1899 alle 15.00 D.C., invece di 1° gennaio 0001 D.C. alle 15.00. Ciò si verifica perché, se si spacifica solo un orario, in .NET Framework e COM viene utilizzata una data predefinita. Si noti che nel sistema COM si utilizza la data di riferimento 30 dicembre 1899 D.C., mentre in .NET Framework si utilizza la data di riferimento 1° gennaio 0001 D.C.

Quando da .NET Framework a COM viene passato soltanto un orario, viene eseguita un'elaborazione speciale che converte l'ora nel formato utilizzato in COM. Quando da COM a .NET Framework viene passato soltanto un orario, non viene eseguita alcuna elaborazione speciale poiché questa danneggerebbe le date e le ore valide corrispondenti o precedenti al 30 dicembre 1899. Ciò significa inoltre che se la data inizia la sequenza di andata e ritorno da COM, .NET Framework e COM manterranno tale data.

Il comportamento di .NET Framework e COM implica che se nell'applicazione viene eseguita una sequenza di andata e ritorno di un oggetto DateTime in cui viene specificato soltanto un orario, è necessario ricordarsi di modificare o ignorare la data errata contenuta nell'oggetto DateTime finale.

Interfacce implementate

Questo tipo implementa le interfacce IComparable, IComparable<T>, IFormattable e IConvertible. Utilizzare la classe Convert per le conversioni anziché l'implementazione del membro esplicito dell'interfaccia IConvertible di questo tipo.

Nell'esempio di codice riportato di seguito viene illustrato il confronto fra valori di oggetti DateTime approssimativamente corrispondenti, accettando un piccolo margine di differenza nella dichiarazione di tali valori come "uguali".

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

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


	}
}


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

    public static void main(String[] args)
    {
        int window = 10;
        int freq = 60 * 60 * 2; // 2 hours;
        DateTime d1 = DateTime.get_Now();
        DateTime d2 = d1.AddSeconds(2 * window);
        DateTime d3 = d1.AddSeconds(-2 * window);
        DateTime d4 = d1.AddSeconds(window / 2);
        DateTime d5 = d1.AddSeconds(-window / 2);

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

        Console.WriteLine("d1 ~= d1 [true]: " 
            + RoughlyEquals(d1, d1, window, freq));
        Console.WriteLine("d1 ~= d2 [false]: " 
            + RoughlyEquals(d1, d2, window, freq));
        Console.WriteLine("d1 ~= d3 [false]: " 
            + RoughlyEquals(d1, d3, window, freq));
        Console.WriteLine("d1 ~= d4 [true]: " 
            + RoughlyEquals(d1, d4, window, freq));
        Console.WriteLine("d1 ~= d5 [true]: " 
            + RoughlyEquals(d1, d5, window, freq));
        Console.WriteLine("d1 ~= d6 [false]: " 
            + RoughlyEquals(d1, d6, window, freq));
        Console.WriteLine("d1 ~= d7 [false]: " 
            + RoughlyEquals(d1, d7, window, freq));
        Console.WriteLine("d1 ~= d8 [true]: " 
            + RoughlyEquals(d1, d8, window, freq));
        Console.WriteLine("d1 ~= d9 [true]: " 
            + RoughlyEquals(d1, d9, window, freq));
    } //main 
} //DateTimeTester 


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

03ybds8y.alert_caution(it-it,VS.90).gifAttenzione:

L'assegnazione di un'istanza di questo tipo non è thread-safe su tutte le piattaforme hardware perché la rappresentazione binaria di tale istanza potrebbe essere troppo estesa per l'assegnazione in un'unica operazione atomica.

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

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supportato in: 3.5, 2.0, 1.0

XNA Framework

Supportato in: 2.0, 1.0

Date

Cronologia

Motivo

Luglio 2008

Aggiunto l'utilizzo di un costruttore predefinito implicito all'elenco di modi per creare un'istanza dell'oggetto DateTime.

Commenti e suggerimenti dei clienti.

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2015 Microsoft