DateTime Struct
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Rappresenta un istante di tempo, in genere espresso come data e ora del giorno.
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattablepublic value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializablepublic value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializablepublic value class DateTime : IComparable, IConvertible, IFormattablepublic value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattablepublic struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattablepublic struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializablepublic struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializablepublic struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattabletype DateTime = struct
interface IConvertible
interface IFormattabletype DateTime = struct
interface IConvertible
interface IFormattable
interface ISerializabletype DateTime = struct
interface IConvertible
interface ISpanFormattable
interface IFormattable
interface ISerializable[<System.Serializable>]
type DateTime = struct
interface IFormattable
interface IConvertible[<System.Serializable>]
type DateTime = struct
interface IFormattable
interface IConvertible
interface ISerializabletype DateTime = struct
interface IFormattablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattablePublic Structure DateTime
Implements IComparable, IConvertible, IFormattablePublic Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable- Ereditarietà
- Attributi
- Implementazioni
Commenti
Importante
Le ere nel calendario giapponese sono basate sul regno dell'imperatore e pertanto è previsto che cambino. Ad esempio, il 1° maggio 2019 contraddistingue l'inizio dell'era Reiwa in JapaneseCalendar e JapaneseLunisolarCalendar. Questo cambio di era interessa tutte le applicazioni che usano questi calendari. Per altre informazioni e per determinare se le applicazioni sono interessate, vedere Gestione di una nuova era nel calendario giapponese in .NET. Per informazioni sul test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento di era, vedere Preparare l'applicazione per la modifica dell'era giapponese. Per le funzionalità in .NET che supportano calendari con più ere e per le procedure consigliate quando si lavora con calendari che supportano più ere, vedere Uso delle ere.
Collegamenti rapidi al codice di esempio
Nota
Alcuni esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.
Il fuso orario locale dello strumento di esecuzione e playground per codice inline Try.NET è Coordinated Universal Time o ora UTC. Ciò può influire sul comportamento e l'output degli esempi che illustrano i tipi DateTime, DateTimeOffset e TimeZoneInfo e i relativi membri.
Questo articolo include diversi esempi che usano il DateTime tipo :
Esempi di inizializzazione
- Richiamare un costruttore
- Richiamare il costruttore implicito senza parametri
- Assegnazione dal valore restituito
- Analisi di una stringa che rappresenta una data e un'ora
- Visual Basic sintassi per inizializzare una data e un'ora
Formattazione DateTime di oggetti come stringhe
- Usare il formato di data/ora predefinito
- Formattare una data e un'ora usando impostazioni cultura specifiche
- Formattare un'ora di data usando una stringa di formato standard o personalizzata
- Specificare sia una stringa di formato che impostazioni cultura specifiche
- Formattare una data e ora usando lo standard ISO 8601 per i servizi Web
Analisi di stringhe come DateTime oggetti
- Usare
Parseo per convertire una stringa in una data eTryParseun'ora - Usare
ParseExacto per convertire una stringa in un formatoTryParseExactnoto - Eseguire la conversione dalla rappresentazione di stringa ISO 8601 a una data e a un'ora
DateTime Risoluzione
- Esplorare la risoluzione dei valori di data e ora
- Confronto per l'uguaglianza all'interno di una tolleranza
Impostazioni cultura e calendari
- Visualizzare i valori di data e ora usando calendari specifici delle impostazioni cultura
- Analizzare le stringhe in base a un calendario specifico delle impostazioni cultura
- Inizializzare una data e un'ora dal calendario di impostazioni cultura specifiche
- Accesso alle proprietà di data e ora usando un calendario di impostazioni cultura specifiche
- Recupero della settimana dell'anno usando calendari specifici delle impostazioni cultura
Persistenza
- Salvataggio permanente dei valori di data e ora come stringhe nel fuso orario locale
- Salvataggio permanente dei valori di data e ora come stringhe in formato invariante delle impostazioni cultura e dell'ora
- Salvataggio permanente dei valori di data e ora come numeri interi
- Salvataggio permanente dei valori di data e ora tramite
XmlSerializer - Salvataggio permanente dei valori di data e ora tramite
BinaryFormatter - Salvataggio permanente dei valori di data e ora con i dati del fuso orario
Collegamenti rapidi ad argomenti relativi alle osservazioni.
Questa sezione contiene argomenti per molti usi comuni dello DateTime struct:
- Inizializzazione di un
DateTimeoggetto - Valori DateTime e relative rappresentazioni di stringa
- Analisi dei valori DateTime dalle stringhe
- Valori DateTime
- Operazioni DateTime
- Risoluzione di DateTime
- Calendari e valori DateTime
- Salvataggio permanente dei valori DateTime
- Confronto tra DateTime e TimeSpan
- Confronto per l'uguaglianza all'interno della tolleranza
- Considerazioni sull'interoperabilità COM
Il tipo di valore rappresenta date e ore con valori compresi tra DateTime 00:00:00 (mezzanotte), 1 gennaio 0001 Anno Domini (era comune) e 11:59:59 P.M., 31 dicembre 9999 d.C. (C.E. nel calendario gregoriano).
I valori di tempo vengono misurati in unità di 100 nanosecondi denominate tick. Una data specifica è il numero di tick a partire dalle 12:00 mezzanotte del 1° gennaio 0001 d.C. (C.E.) nel GregorianCalendar calendario. Il numero esclude i tick che verrebbero aggiunti da secondi intercalare. Ad esempio, un valore tick 31241376000000000L rappresenta la data venerdì 01 gennaio 0100 12:00:00 mezzanotte. Un DateTime valore viene sempre espresso nel contesto di un calendario esplicito o predefinito.
Nota
Se si usa un valore di tick che si vuole convertire in un altro intervallo di tempo, ad esempio minuti o secondi, è necessario usare la costante , , , o per eseguire la TimeSpan.TicksPerDay TimeSpan.TicksPerHour TimeSpan.TicksPerMinute TimeSpan.TicksPerSecond TimeSpan.TicksPerMillisecond conversione. Ad esempio, per aggiungere il numero di secondi rappresentati da un numero specificato di tick al componente di un valore, è possibile Second DateTime usare l'espressione dateValue.Second + nTicks/Timespan.TicksPerSecond .
È possibile visualizzare l'origine per l'intero set di esempi di questo articolo in Visual Basic o C# dal repository docs in GitHub.
Nota
Un'alternativa alla DateTime struttura per l'utilizzo di valori di data e ora in fusi orari specifici è la DateTimeOffset struttura . La struttura archivia le informazioni di data e ora in un campo privato e il numero di minuti in base al quale la data e l'ora differiscono DateTimeOffset dall'ora UTC in un campo DateTime Int16 privato. Ciò consente a un valore di riflettere l'ora in un fuso orario specifico, mentre un valore può riflettere in modo non ambiguo solo DateTimeOffset DateTime l'ora UTC e l'ora del fuso orario locale. Per informazioni su quando usare la struttura o la struttura quando si usano valori di data e ora, vedere Scelta tra DateTime DateTimeOffset DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.
Inizializzazione di un oggetto DateTime
È possibile assegnare un valore iniziale a un DateTime nuovo valore in molti modi diversi:
- Chiamare un costruttore, uno in cui si specificano argomenti per i valori o usare il costruttore implicito senza parametri.
- Assegnazione di un
DateTimeoggetto al valore restituito di una proprietà o di un metodo. - Analisi di un
DateTimevalore dalla relativa rappresentazione di stringa. - Uso Visual Basic specifiche del linguaggio per creare un'istanza di
DateTime.
I frammenti di codice seguenti illustrano esempi di ognuno:
Richiamare costruttori
Chiamare uno degli overload del costruttore che specificano gli elementi del valore di data e ora , ad esempio anno, mese e giorno o il DateTime numero di tick. Il codice seguente crea una data specifica usando il DateTime costruttore che specifica anno, mese, giorno, ora, minuto e secondo.
Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);
Il costruttore implicito senza parametri della struttura viene richiamato quando si vuole inizializzare un oggetto DateTime sul relativo valore DateTime predefinito. Per informazioni dettagliate sul costruttore implicito senza parametri di un tipo di valore, vedere Tipi di valore. Alcuni compilatori supportano anche la dichiarazione di un DateTime valore senza assegnare un valore in modo esplicito. La creazione di un valore senza un'inizializzazione esplicita comporta anche il valore predefinito. L'esempio seguente illustra il costruttore implicito senza parametri in C# e Visual Basic, nonché una dichiarazione senza assegnazione DateTime DateTime in Visual Basic.
Dim dat1 As DateTime
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat1.Equals(Date.MinValue))
Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))
var dat1 = new DateTime();
// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));
Assegnazione di un valore calcolato
È possibile assegnare DateTime all'oggetto un valore di data e ora restituito da una proprietà o un metodo. Nell'esempio seguente vengono assegnati la data e l'ora correnti, la data e l'ora Coordinated Universal Time (UTC) e la data corrente a tre nuove DateTime variabili.
Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today
DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;
Analisi di una stringa che rappresenta un valore DateTime
I Parse metodi , , e ParseExact TryParse TryParseExact convertono tutti una stringa nel valore di data e ora equivalente. Negli esempi seguenti vengono utilizzati Parse i metodi e per analizzare una stringa e ParseExact convertirla in un valore DateTime . Il secondo formato usa un formato supportato dallo standard ISO 8601 per una rappresentazione di data e ora in formato stringa. Questa rappresentazione standard viene spesso usata per trasferire informazioni sulla data nei servizi Web.
Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)
var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
System.Globalization.CultureInfo.InvariantCulture);
I metodi e indicano se una stringa è una rappresentazione valida di un valore e, in caso TryParse TryParseExact DateTime contrario, esegue la conversione.
Sintassi specifica del linguaggio per Visual Basic
L'istruzione Visual Basic seguente inizializza un nuovo DateTime valore.
Dim date1 As Date = #5/1/2008 8:30:52AM#
Valori DateTime e relative rappresentazioni di stringa
Internamente, tutti i valori sono rappresentati come numero di tick (il numero di intervalli di DateTime 100 nanosecondi) trascorsi dalle 12:00:00 mezzanotte del 1° gennaio 0001. Il valore DateTime effettivo è indipendente dal modo in cui tale valore viene visualizzato quando viene visualizzato. L'aspetto di un valore è il risultato di un'operazione di formattazione DateTime che converte un valore nella relativa rappresentazione di stringa.
L'aspetto dei valori di data e ora dipende dalle impostazioni cultura, gli standard internazionali, i requisiti dell'applicazione e le preferenze personali. La DateTime struttura offre flessibilità nella formattazione dei valori di data e ora tramite overload di ToString . Il metodo predefinito restituisce la rappresentazione di stringa di un valore di data e ora usando il modello di data breve e ora lungo delle impostazioni cultura DateTime.ToString() correnti. Nell'esempio seguente viene utilizzato il metodo DateTime.ToString() predefinito. Visualizza la data e l'ora usando il modello di data breve e ora lunga per le impostazioni cultura correnti. Le impostazioni cultura en-US sono le impostazioni cultura correnti nel computer in cui è stato eseguito l'esempio.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM
Potrebbe essere necessario formattare le date con impostazioni cultura specifiche per supportare scenari Web in cui il server potrebbe avere impostazioni cultura diverse rispetto al client. Specificare le impostazioni cultura usando il metodo per creare la rappresentazione di data breve e ora DateTime.ToString(IFormatProvider) lunga in impostazioni cultura specifiche. Nell'esempio seguente viene utilizzato il metodo per visualizzare la data e l'ora usando il modello di data breve e ora lunga per le impostazioni cultura DateTime.ToString(IFormatProvider) fr-FR.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00
Altre applicazioni possono richiedere rappresentazioni di stringa diverse di una data. Il metodo restituisce la rappresentazione di stringa definita da un identificatore di formato standard o personalizzato usando le convenzioni DateTime.ToString(String) di formattazione delle impostazioni cultura correnti. Nell'esempio seguente viene utilizzato il metodo per visualizzare il modello di data e ora completo per le impostazioni cultura en-US, ovvero le impostazioni cultura correnti nel computer in cui è stato eseguito DateTime.ToString(String) l'esempio.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM
Infine, è possibile specificare le impostazioni cultura e il formato usando il DateTime.ToString(String, IFormatProvider) metodo . Nell'esempio seguente viene utilizzato il metodo per visualizzare il modello di data e DateTime.ToString(String, IFormatProvider) ora completo per le impostazioni cultura fr-FR.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00
DateTime.ToString(String)L'overload può essere usato anche con una stringa di formato personalizzata per specificare altri formati. L'esempio seguente illustra come formattare una stringa usando il formato standard ISO 8601 spesso usato per i servizi Web. Il formato Iso 8601 non ha una stringa di formato standard corrispondente.
var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"));
// Displays 20080301T07:00:00Z
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"))
' Displays 20080301T07:00:00Z
Per altre informazioni sui valori di formattazione, vedere Stringhe di formato di data e ora DateTime standard e Stringhe di formato di data e ora personalizzate.
Analisi dei valori DateTime dalle stringhe
L'analisi converte la rappresentazione di stringa di una data e di un'ora in un DateTime valore . In genere, le stringhe di data e ora hanno due utilizzi diversi nelle applicazioni:
Una data e un'ora accettano diversi formati e riflettono le convenzioni delle impostazioni cultura correnti o di impostazioni cultura specifiche. Ad esempio, un'applicazione consente a un utente le cui impostazioni cultura correnti sono en-US di immettere un valore di data come "15/12/2013" o "15 dicembre 2013". Consente a un utente le cui impostazioni cultura correnti sono en-gb di immettere un valore di data come "15/12/2013" o "15 dicembre 2013".
Una data e un'ora sono rappresentate in un formato predefinito. Ad esempio, un'applicazione serializza una data come "20130103" indipendentemente dalle impostazioni cultura in cui è in esecuzione l'app. Un'applicazione può richiedere l'immissione di date nel formato di data breve delle impostazioni cultura correnti.
Usare il metodo o per convertire una stringa da uno dei formati di data e ora comuni usati dalle impostazioni cultura Parse TryParse in un valore DateTime . Nell'esempio seguente viene illustrato come usare per convertire stringhe TryParse di data in formati diversi specifici delle impostazioni cultura in un valore DateTime . Modifica le impostazioni cultura correnti in inglese (Gran Bretagna) e chiama il metodo per generare una GetDateTimeFormats() matrice di stringhe di data e ora. Passa quindi ogni elemento della matrice al TryParse metodo . L'output dell'esempio mostra che il metodo di analisi è stato in grado di convertire correttamente ognuna delle stringhe di data e ora specifiche delle impostazioni cultura.
System.Threading.Thread.CurrentThread.CurrentCulture =
System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
var date1 = new DateTime(2013, 6, 1, 12, 32, 30);
var badFormats = new List<String>();
Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
DateTime parsedDate;
if (DateTime.TryParse(dateString, out parsedDate))
Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
else
badFormats.Add(dateString);
}
// Display strings that could not be parsed.
if (badFormats.Count > 0)
{
Console.WriteLine("\nStrings that could not be parsed: ");
foreach (var badFormat in badFormats)
Console.WriteLine($" {badFormat}");
}
// Press "Run" to see the output.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)
Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
Dim parsedDate As DateTime
If DateTime.TryParse(dateString, parsedDate) Then
Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
Else
badFormats.Add(dateString)
End If
Next
' Display strings that could not be parsed.
If badFormats.Count > 0 Then
Console.WriteLine()
Console.WriteLine("Strings that could not be parsed: ")
For Each badFormat In badFormats
Console.WriteLine($" {badFormat}")
Next
End If
' The example displays the following output:
' Date String Date
'
' 01/06/2013 01/06/2013 00:00:00
' 01/06/13 01/06/2013 00:00:00
' 1/6/13 01/06/2013 00:00:00
' 1.6.13 01/06/2013 00:00:00
' 2013-06-01 01/06/2013 00:00:00
' 01 June 2013 01/06/2013 00:00:00
' 1 June 2013 01/06/2013 00:00:00
' 01 June 2013 12:32 01/06/2013 12:32:00
' 01 June 2013 12:32 01/06/2013 12:32:00
' 01 June 2013 12:32 PM 01/06/2013 12:32:00
' 01 June 2013 12:32 PM 01/06/2013 12:32:00
' 1 June 2013 12:32 01/06/2013 12:32:00
' 1 June 2013 12:32 01/06/2013 12:32:00
' 1 June 2013 12:32 PM 01/06/2013 12:32:00
' 1 June 2013 12:32 PM 01/06/2013 12:32:00
' 01 June 2013 12:32:30 01/06/2013 12:32:30
' 01 June 2013 12:32:30 01/06/2013 12:32:30
' 01 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 01 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 1 June 2013 12:32:30 01/06/2013 12:32:30
' 1 June 2013 12:32:30 01/06/2013 12:32:30
' 1 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 1 June 2013 12:32:30 PM 01/06/2013 12:32:30
' 01/06/2013 12:32 01/06/2013 12:32:00
' 01/06/2013 12:32 01/06/2013 12:32:00
' 01/06/2013 12:32 PM 01/06/2013 12:32:00
' 01/06/2013 12:32 PM 01/06/2013 12:32:00
' 01/06/13 12:32 01/06/2013 12:32:00
' 01/06/13 12:32 01/06/2013 12:32:00
' 01/06/13 12:32 PM 01/06/2013 12:32:00
' 01/06/13 12:32 PM 01/06/2013 12:32:00
' 1/6/13 12:32 01/06/2013 12:32:00
' 1/6/13 12:32 01/06/2013 12:32:00
' 1/6/13 12:32 PM 01/06/2013 12:32:00
' 1/6/13 12:32 PM 01/06/2013 12:32:00
' 1.6.13 12:32 01/06/2013 12:32:00
' 1.6.13 12:32 01/06/2013 12:32:00
' 1.6.13 12:32 PM 01/06/2013 12:32:00
' 1.6.13 12:32 PM 01/06/2013 12:32:00
' 2013-06-01 12:32 01/06/2013 12:32:00
' 2013-06-01 12:32 01/06/2013 12:32:00
' 2013-06-01 12:32 PM 01/06/2013 12:32:00
' 2013-06-01 12:32 PM 01/06/2013 12:32:00
' 01/06/2013 12:32:30 01/06/2013 12:32:30
' 01/06/2013 12:32:30 01/06/2013 12:32:30
' 01/06/2013 12:32:30 PM 01/06/2013 12:32:30
' 01/06/2013 12:32:30 PM 01/06/2013 12:32:30
' 01/06/13 12:32:30 01/06/2013 12:32:30
' 01/06/13 12:32:30 01/06/2013 12:32:30
' 01/06/13 12:32:30 PM 01/06/2013 12:32:30
' 01/06/13 12:32:30 PM 01/06/2013 12:32:30
' 1/6/13 12:32:30 01/06/2013 12:32:30
' 1/6/13 12:32:30 01/06/2013 12:32:30
' 1/6/13 12:32:30 PM 01/06/2013 12:32:30
' 1/6/13 12:32:30 PM 01/06/2013 12:32:30
' 1.6.13 12:32:30 01/06/2013 12:32:30
' 1.6.13 12:32:30 01/06/2013 12:32:30
' 1.6.13 12:32:30 PM 01/06/2013 12:32:30
' 1.6.13 12:32:30 PM 01/06/2013 12:32:30
' 2013-06-01 12:32:30 01/06/2013 12:32:30
' 2013-06-01 12:32:30 01/06/2013 12:32:30
' 2013-06-01 12:32:30 PM 01/06/2013 12:32:30
' 2013-06-01 12:32:30 PM 01/06/2013 12:32:30
' 01 June 01/06/2013 00:00:00
' 01 June 01/06/2013 00:00:00
' 2013-06-01T12:32:30.0000000 01/06/2013 12:32:30
' 2013-06-01T12:32:30.0000000 01/06/2013 12:32:30
' Sat, 01 Jun 2013 12:32:30 GMT 01/06/2013 05:32:30
' Sat, 01 Jun 2013 12:32:30 GMT 01/06/2013 05:32:30
' 2013-06-01T12:32:30 01/06/2013 12:32:30
' 12:32 22/04/2013 12:32:00
' 12:32 22/04/2013 12:32:00
' 12:32 PM 22/04/2013 12:32:00
' 12:32 PM 22/04/2013 12:32:00
' 12:32:30 22/04/2013 12:32:30
' 12:32:30 22/04/2013 12:32:30
' 12:32:30 PM 22/04/2013 12:32:30
' 12:32:30 PM 22/04/2013 12:32:30
' 2013-06-01 12:32:30Z 01/06/2013 05:32:30
' 01 June 2013 19:32:30 01/06/2013 19:32:30
' 01 June 2013 19:32:30 01/06/2013 19:32:30
' 01 June 2013 07:32:30 PM 01/06/2013 19:32:30
' 01 June 2013 7:32:30 PM 01/06/2013 19:32:30
' 1 June 2013 19:32:30 01/06/2013 19:32:30
' 1 June 2013 19:32:30 01/06/2013 19:32:30
' 1 June 2013 07:32:30 PM 01/06/2013 19:32:30
' 1 June 2013 7:32:30 PM 01/06/2013 19:32:30
' June 2013 01/06/2013 00:00:00
' June 2013 01/06/2013 00:00:00
Usare i metodi e per convertire una stringa che deve corrispondere a uno o più formati ParseExact specifici in un valore TryParseExact DateTime . Una o più stringhe di formato di data e ora vengono specificate come parametro per il metodo di analisi. Nell'esempio seguente viene utilizzato il metodo per convertire in valori le stringhe che devono essere in formato TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) "yyyyMMdd" o "HHmmss". DateTime
string[] formats = { "yyyyMMdd", "HHmmss" };
string[] dateStrings = { "20130816", "20131608", " 20130816 ",
"115216", "521116", " 115216 " };
DateTime parsedDate;
foreach (var dateString in dateStrings)
{
if (DateTime.TryParseExact(dateString, formats, null,
System.Globalization.DateTimeStyles.AllowWhiteSpaces |
System.Globalization.DateTimeStyles.AdjustToUniversal,
out parsedDate))
Console.WriteLine($"{dateString} --> {parsedDate:g}");
else
Console.WriteLine($"Cannot convert {dateString}");
}
// The example displays the following output:
// 20130816 --> 8/16/2013 12:00 AM
// Cannot convert 20131608
// 20130816 --> 8/16/2013 12:00 AM
// 115216 --> 4/22/2013 11:52 AM
// Cannot convert 521116
// 115216 --> 4/22/2013 11:52 AM
Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
" 20130816 ", "115216",
"521116", " 115216 "}
Dim parsedDate As DateTime
For Each dateString As String In dateStrings
If DateTime.TryParseExact(dateString, formats, Nothing,
DateTimeStyles.AllowWhiteSpaces Or
DateTimeStyles.AdjustToUniversal,
parsedDate) Then
Console.WriteLine($"{dateString} --> {parsedDate:g}")
Else
Console.WriteLine($"Cannot convert {dateString}")
End If
Next
' The example displays the following output:
' 20130816 --> 8/16/2013 12:00 AM
' Cannot convert 20131608
' 20130816 --> 8/16/2013 12:00 AM
' 115216 --> 4/22/2013 11:52 AM
' Cannot convert 521116
' 115216 --> 4/22/2013 11:52 AM
Un uso comune di per è la conversione di una rappresentazione di stringa da ParseExact un servizio Web, in genere in formato standard ISO 8601. Il codice seguente illustra la stringa di formato corretta da usare:
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")
Se non è possibile analizzare una stringa, i Parse metodi e ParseExact generano un'eccezione. I TryParse metodi TryParseExact e restituiscono un valore che indica se Boolean la conversione ha avuto esito positivo o negativo. È consigliabile usare TryParse i metodi o negli scenari in cui le prestazioni sono TryParseExact importanti. L'operazione di analisi per le stringhe di data e ora tende a avere una frequenza di errore elevata e la gestione delle eccezioni è costosa. Usare questi metodi se le stringhe vengono immesse dagli utenti o provenienti da un'origine sconosciuta.
Per altre informazioni sull'analisi dei valori di data e ora, vedere Analisi di stringhe di data e ora.
Valori DateTime
Le descrizioni dei valori di ora nel tipo vengono spesso espresse usando DateTime lo standard Coordinated Universal Time (UTC). Coordinated Universal Time è il nome riconosciuto a livello internazionale per Greenwich Mean Time (GMT). Coordinated Universal Time è l'ora misurata in gradi di longitudine zero, il punto di origine UTC. L'ora legale non è applicabile all'ora UTC.
L'ora locale è relativa a un fuso orario specifico. Un fuso orario è associato a una controparte del fuso orario. Una differenza di fuso orario è lo spostamento del fuso orario misurato in ore dal punto di origine UTC. Inoltre, l'ora locale è facoltativamente interessata dall'ora legale, che aggiunge o sottrae una regolazione dell'intervallo di tempo. L'ora locale viene calcolata aggiungendo la differenza di fuso orario all'ora UTC e regolando l'ora legale, se necessario. L'offset del fuso orario nel punto di origine UTC è zero.
L'ora UTC è adatta per calcoli, confronti e archiviazione di date e ore nei file. L'ora locale è appropriata per la visualizzazione nelle interfacce utente delle applicazioni desktop. Anche le applicazioni in grado di riconoscere il fuso orario, ad esempio molte applicazioni Web, devono funzionare con diversi altri fusi orari.
Se la proprietà di un oggetto è , non viene specificato se l'ora rappresentata è l'ora locale, l'ora UTC o un'ora Kind in un altro fuso DateTime DateTimeKind.Unspecified orario.
Risoluzione di DateTime
Nota
In alternativa all'esecuzione di operazioni aritmetiche di data e ora sui valori per misurare il tempo trascorso, è possibile DateTime usare la Stopwatch classe .
La Ticks proprietà esprime i valori di data e ora in unità di un decimi di secondo. La Millisecond proprietà restituisce i millesimo di secondo in un valore di data e ora. L'uso di chiamate DateTime.Now ripetute alla proprietà per misurare il tempo trascorso dipende dall'orologio di sistema. L'orologio di sistema Windows 7 e Windows 8 ha una risoluzione di circa 15 millisecondi. Questa risoluzione influisce su intervalli di tempo minori di 100 millisecondi.
Nell'esempio seguente viene illustrata la dipendenza dei valori di data e ora correnti dalla risoluzione dell'orologio di sistema. Nell'esempio un ciclo esterno viene ripetuto 20 volte e un ciclo interno serve a ritardare il ciclo esterno. Se il valore del contatore del ciclo esterno è 10, una chiamata al metodo introduce un ritardo Thread.Sleep di cinque millisecondi. Nell'esempio seguente viene illustrato il numero di millisecondi restituiti dalla proprietà DateTime.Now.Milliseconds solo dopo la chiamata a Thread.Sleep .
string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
output += String.Format($"{DateTime.Now.Millisecond}\n");
// Introduce a delay loop.
for (int delay = 0; delay <= 1000; delay++)
{ }
if (ctr == 10)
{
output += "Thread.Sleep called...\n";
System.Threading.Thread.Sleep(5);
}
}
Console.WriteLine(output);
// Press "Run" to see the output.
Dim output As String = ""
For ctr As Integer = 0 To 20
output += Date.Now.Millisecond.ToString() + vbCrLf
' Introduce a delay loop.
For delay As Integer = 0 To 1000
Next
If ctr = 10 Then
output += "Thread.Sleep called..." + vbCrLf
Thread.Sleep(5)
End If
Next
Console.WriteLine(output)
' The example displays output like the following:
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' 111
' Thread.Sleep called...
' 143
' 143
' 143
' 143
' 143
' 143
' 143
' 143
' 143
' 143
Operazioni DateTime
Un calcolo che DateTime usa una struttura, ad esempio Add o , non modifica il valore della Subtract struttura. Il calcolo restituisce invece una nuova DateTime struttura il cui valore è il risultato del calcolo.
Le operazioni di conversione tra fusi orari (ad esempio tra l'ora UTC e l'ora locale o tra un fuso orario e un altro) prendono in considerazione l'ora legale, ma non le operazioni aritmetiche e di confronto.
La DateTime struttura stessa offre un supporto limitato per la conversione da un fuso orario a un altro. È possibile usare il metodo per convertire l'ora UTC in ora locale oppure il metodo per eseguire la conversione dall'ora locale ToLocalTime ToUniversalTime all'ora UTC. Tuttavia, nella classe è disponibile un set completo di metodi di conversione del fuso TimeZoneInfo orario. È possibile convertire l'ora in uno dei fusi orari del mondo nell'ora in qualsiasi altro fuso orario usando questi metodi.
I calcoli e i confronti degli oggetti sono significativi solo se gli DateTime oggetti rappresentano orari nello stesso fuso orario. È possibile usare un oggetto per rappresentare il fuso orario di un TimeZoneInfo DateTime valore, anche se i due sono in coppia. Un oggetto non dispone di una proprietà che restituisce un oggetto che rappresenta il fuso orario del valore di data DateTime e ora. La Kind proprietà indica se un oggetto rappresenta l'ora UTC, l'ora DateTime locale o non è specificato. In un'applicazione in grado di riconoscere il fuso orario, è necessario basarsi su un meccanismo esterno per determinare il fuso orario in cui è stato DateTime creato un oggetto . È possibile usare una struttura che esegue il wrapping sia del DateTime valore che TimeZoneInfo dell'oggetto che rappresenta il DateTime fuso orario del valore. Per informazioni dettagliate sull'uso dell'ora UTC nei calcoli e nei confronti con i valori, vedere Esecuzione di operazioni DateTime aritmetiche con date e ore.
Ogni DateTime membro usa in modo implicito il calendario gregoriano per eseguire l'operazione. Le eccezioni sono metodi che specificano in modo implicito un calendario. Sono inclusi i costruttori che specificano un calendario e i metodi con un parametro derivato da IFormatProvider , ad esempio System.Globalization.DateTimeFormatInfo .
Le operazioni eseguite dai membri del tipo prendono in considerazione dettagli quali gli anni DateTime bisestest e il numero di giorni in un mese.
Calendari e valori DateTime
La .NET Framework di classi include una serie di classi di calendario, tutte derivate dalla Calendar classe . Ad esempio:
- Classe ChineseLunisolarCalendar.
- Classe EastAsianLunisolarCalendar.
- Classe GregorianCalendar.
- Classe HebrewCalendar.
- Classe HijriCalendar.
- Classe JapaneseCalendar.
- Classe JapaneseLunisolarCalendar.
- Classe JulianCalendar.
- Classe KoreanCalendar.
- Classe KoreanLunisolarCalendar.
- Classe PersianCalendar.
- Classe TaiwanCalendar.
- Classe TaiwanLunisolarCalendar.
- Classe ThaiBuddhistCalendar.
- Classe UmAlQuraCalendar.
Importante
Le ere nel calendario giapponese sono basate sul regno dell'imperatore e pertanto è previsto che cambino. Ad esempio, il 1° maggio 2019 contraddistingue l'inizio dell'era Reiwa in JapaneseCalendar e JapaneseLunisolarCalendar. Questo cambio di era interessa tutte le applicazioni che usano questi calendari. Per altre informazioni e per determinare se le applicazioni sono interessate, vedere Gestione di una nuova era nel calendario giapponese in .NET. Per informazioni sul test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento di era, vedere Preparare l'applicazione per la modifica dell'era giapponese. Per le funzionalità in .NET che supportano calendari con più ere e per le procedure consigliate quando si lavora con calendari che supportano più ere, vedere Uso delle ere.
Ogni impostazione cultura usa un calendario predefinito definito dalla relativa proprietà di sola CultureInfo.Calendar lettura. Ogni impostazione cultura può supportare uno o più calendari definiti dalla relativa proprietà di sola CultureInfo.OptionalCalendars lettura. Il calendario attualmente utilizzato da un oggetto CultureInfo specifico è definito dalla relativa proprietà DateTimeFormatInfo.Calendar . Deve essere uno dei calendari trovati nella CultureInfo.OptionalCalendars matrice .
Il calendario corrente delle impostazioni cultura viene usato in tutte le operazioni di formattazione per le impostazioni cultura. Ad esempio, il calendario predefinito delle impostazioni cultura tailandesi della lingua tailandese è il calendario thai dell'era thai, rappresentato dalla ThaiBuddhistCalendar classe . Quando in un'operazione di formattazione di data e ora viene usato un oggetto che rappresenta le impostazioni cultura tailandesi, per impostazione predefinita viene usato il calendario thai CultureInfo dell'era thai. Il calendario gregoriano viene usato solo se la proprietà delle impostazioni DateTimeFormatInfo.Calendar cultura viene modificata, come illustrato nell'esempio seguente:
var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);
Console.WriteLine(value.ToString(thTH));
thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
// 28/5/2559 0:00:00
// 28/5/2016 0:00:00
Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)
Console.WriteLine(value.ToString(thTH))
thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
' 28/5/2559 0:00:00
' 28/5/2016 0:00:00
Il calendario corrente delle impostazioni cultura viene usato anche in tutte le operazioni di analisi per le impostazioni cultura, come illustrato nell'esempio seguente.
var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));
thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
// 28/5/2559 0:00:00
// 28/5/2016 0:00:00
Private Sub ThaiBuddhistEraParse()
Dim thTH As New CultureInfo("th-TH")
Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
Console.WriteLine(value.ToString(thTH))
thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
' 28/5/2559 0:00:00
' 28/5/2016 0:00:00
End Sub
È possibile creare un'istanza di un valore usando gli elementi di data e ora (numero dell'anno, del mese e del giorno) di un calendario specifico chiamando un costruttore DateTime che include un parametro e passando un oggetto che rappresenta tale DateTime calendar Calendar calendario. Nell'esempio seguente vengono utilizzati gli elementi di data e ora del ThaiBuddhistCalendar calendario.
var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date: {dat:d}");
// The example displays the following output:
// Thai Buddhist Era Date: 28/5/2559
// Gregorian Date: 28/05/2016
Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date: {dat:d}")
' The example displays the following output:
' Thai Buddhist Era Date: 28/5/2559
' Gregorian Date: 28/05/2016
DateTime I costruttori che non includono un parametro presuppongono che gli elementi di data e ora siano calendar espressi come unità nel calendario gregoriano.
Tutti gli DateTime altri metodi e proprietà usano il calendario gregoriano. Ad esempio, la proprietà restituisce l'anno nel calendario gregoriano e il metodo presuppone che il parametro sia un DateTime.Year DateTime.IsLeapYear(Int32) anno nel calendario year gregoriano. Ogni DateTime membro che utilizza il calendario gregoriano ha un membro corrispondente della classe che utilizza un calendario Calendar specifico. Ad esempio, il metodo restituisce l'anno in un calendario specifico e il metodo interpreta il parametro come numero Calendar.GetYear di anno in un calendario Calendar.IsLeapYear year specifico. Nell'esempio seguente vengono utilizzati DateTime sia che i membri corrispondenti della classe ThaiBuddhistCalendar .
var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
// Using the Thai Buddhist Era calendar
// Date : 28/5/2559
// Year: 2559
// Leap year : True
//
// Using the Gregorian calendar
// Date : 28/05/2016
// Year: 2016
// Leap year : True
Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
' Using the Thai Buddhist Era calendar
' Date : 28/5/2559
' Year: 2559
' Leap year : True
'
' Using the Gregorian calendar
' Date : 28/05/2016
' Year: 2016
' Leap year : True
La DateTime struttura include una proprietà che restituisce il giorno della settimana nel calendario DayOfWeek gregoriano. Non include un membro che consente di recuperare il numero di settimana dell'anno. Per recuperare la settimana dell'anno, chiamare il metodo del singolo Calendar.GetWeekOfYear calendario. Nell'esempio seguente viene illustrato questo concetto.
var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");
var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
// Using the Thai Buddhist Era calendar
// Date : 18/8/1395
// Day of Week: Sunday
// Week of year: 34
//
// Using the Gregorian calendar
// Date : 18/08/0852
// Day of Week: Sunday
// Week of year: 34
Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()
Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
' Using the Thai Buddhist Era calendar
' Date : 18/8/1395
' Day of Week: Sunday
' Week of year: 34
'
' Using the Gregorian calendar
' Date : 18/08/0852
' Day of Week: Sunday
' Week of year: 34
Per altre informazioni su date e calendari, vedere Utilizzo dei calendari.
Persistenza dei valori DateTime
È possibile rendere DateTime persistenti i valori in quattro modi:
- È possibile convertirle in stringhe e rendere persistenti le stringhe.
- È possibile convertirli in valori interi a 64 bit (il valore della proprietà ) e rendere Ticks persistenti i numeri interi.
- Serializzare i valori DateTime.
- Serializzare i valori DateTime insieme alle informazioni sul fuso orario.
È necessario assicurarsi che la routine che ripristina i valori non perda dati o non genera un'eccezione indipendentemente DateTime dalla tecnica scelta. DateTime I valori devono essere round trip. Ciò significa che il valore originale e il valore ripristinato devono essere uguali. E se il valore originale rappresenta un singolo istante di tempo, deve identificare lo stesso momento in cui DateTime viene ripristinato.
Persistenza dei valori come stringhe
Per ripristinare correttamente DateTime i valori persistenti come stringhe, seguire queste regole:
Fare le stesse ipotesi sulla formattazione specifica delle impostazioni cultura quando si ripristina la stringa come quando è stata resa persistente. Per assicurarsi che una stringa possa essere ripristinata in un sistema le cui impostazioni cultura correnti sono diverse dalle impostazioni cultura del sistema in cui è stata salvata, chiamare l'overload per salvare la stringa usando le convenzioni delle impostazioni cultura ToString invarianti. Chiamare Parse(String, IFormatProvider, DateTimeStyles) TryParse(String, IFormatProvider, DateTimeStyles, DateTime) l'overload o per ripristinare la stringa usando le convenzioni delle impostazioni cultura invarianti. Non usare mai ToString() gli overload , o , che usano le Parse(String) TryParse(String, DateTime) convenzioni delle impostazioni cultura correnti.
Se la data rappresenta un singolo momento, assicurarsi che rappresenti lo stesso momento in cui viene ripristinata, anche in un fuso orario diverso. Convertire il DateTime valore in Coordinated Universal Time (UTC) prima di salvarlo. È anche possibile serializzare il valore insieme alle informazioni sul fuso orario. Per altre informazioni su questo approccio, vedere Serializing DateTime and time zone data.
L'errore più comune che si verifica durante la persistenza dei valori come stringhe è basarsi sulle convenzioni di formattazione delle impostazioni cultura predefinite DateTime o correnti. I problemi si verificano se le impostazioni cultura correnti sono diverse durante il salvataggio e il ripristino delle stringhe. Nell'esempio seguente vengono illustrati questi problemi. Salva cinque date usando le convenzioni di formattazione delle impostazioni cultura correnti, che in questo caso sono l'inglese (Stati Uniti). Ripristina le date usando le convenzioni di formattazione di impostazioni cultura diverse, che in questo caso sono l'inglese (Gran Francia). Poiché le convenzioni di formattazione delle due impostazioni cultura sono diverse, due delle date non possono essere ripristinate e le tre date rimanenti vengono interpretate in modo non corretto. Inoltre, se i valori di data e ora originali rappresentano singoli istanti nel tempo, le ore ripristinate non sono corrette perché le informazioni sul fuso orario vengono perse.
public static void PersistAsLocalStrings()
{
SaveLocalDatesAsString();
RestoreLocalDatesFromString();
}
private static void SaveLocalDatesAsString()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
string output = null;
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
}
var sw = new StreamWriter(filenameTxt);
sw.Write(output);
sw.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreLocalDatesFromString()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
StreamReader sr = new StreamReader(filenameTxt);
string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
StringSplitOptions.RemoveEmptyEntries);
sr.Close();
Console.WriteLine("The dates on an {0} system:",
Thread.CurrentThread.CurrentCulture.Name);
foreach (var inputValue in inputValues)
{
DateTime dateValue;
if (DateTime.TryParse(inputValue, out dateValue))
{
Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
}
else
{
Console.WriteLine("Cannot parse '{inputValue}'");
}
}
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// Cannot parse //6/14/2014 6:32:00 AM//
// //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
// //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
// Cannot parse //12/20/2014 9:45:00 PM//
// //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
// Restored dates...
Public Sub PersistAsLocalStrings()
SaveDatesAsStrings()
RestoreDatesAsStrings()
End Sub
Private Sub SaveDatesAsStrings()
Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
#1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
#6/2/2014 3:14PM#}
Dim output As String = Nothing
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
For ctr As Integer = 0 To dates.Length - 1
Console.WriteLine(dates(ctr).ToString("f"))
output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
Next
Dim sw As New StreamWriter(filenameTxt)
sw.Write(output)
sw.Close()
Console.WriteLine("Saved dates...")
End Sub
Private Sub RestoreDatesAsStrings()
TimeZoneInfo.ClearCachedData()
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Dim sr As New StreamReader(filenameTxt)
Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
sr.Close()
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
For Each inputValue In inputValues
Dim dateValue As Date
If DateTime.TryParse(inputValue, dateValue) Then
Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
Else
Console.WriteLine($"Cannot parse '{inputValue}'")
End If
Next
Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
' Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
' The dates on an en-US system:
' Saturday, June 14, 2014 6:32 AM
' Thursday, July 10, 2014 11:49 PM
' Saturday, January 10, 2015 1:16 AM
' Saturday, December 20, 2014 9:45 PM
' Monday, June 02, 2014 3:14 PM
' Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
' Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
' The dates on an en-GB system:
' Cannot parse '6/14/2014 6:32:00 AM'
' '7/10/2014 11:49:00 PM' --> 07 October 2014 23:49
' '1/10/2015 1:16:00 AM' --> 01 October 2015 01:16
' Cannot parse '12/20/2014 9:45:00 PM'
' '6/2/2014 3:14:00 PM' --> 06 February 2014 15:14
' Restored dates...
Per eseguire correttamente il round trip DateTime dei valori, seguire questa procedura:
- Se i valori rappresentano singoli istanti di tempo, convertirli dall'ora locale all'ora UTC chiamando il ToUniversalTime metodo .
- Convertire le date nelle relative rappresentazioni di stringa chiamando ToString(String, IFormatProvider) String.Format(IFormatProvider, String, Object[]) l'overload o . Usare le convenzioni di formattazione delle impostazioni cultura invarianti specificando CultureInfo.InvariantCulture come
providerargomento . Specificare che il valore deve eseguire il round trip usando la stringa di formato standard "O" o "R".
Per ripristinare i valori DateTime persistenti senza perdita di dati, seguire questa procedura:
- Analizzare i dati chiamando ParseExact TryParseExact l'overload o . Specificare CultureInfo.InvariantCulture come argomento e usare la stessa stringa di formato standard usata per
providerformatl'argomento durante la conversione. Includere il DateTimeStyles.RoundtripKind valorestylesnell'argomento . - Se i valori rappresentano singoli momenti nel tempo, chiamare il metodo per convertire la data DateTime ToLocalTime analizzata dall'ora UTC all'ora locale.
Nell'esempio seguente vengono utilizzate le impostazioni cultura invarianti e la stringa di formato standard "O" per garantire che i valori salvati e ripristinati rappresentino lo stesso momento indipendentemente dal sistema, dalle impostazioni cultura o dal fuso orario dei sistemi di origine e di DateTime destinazione.
public static void PersistAsInvariantStrings()
{
SaveDatesAsInvariantStrings();
RestoreDatesAsInvariantStrings();
}
private static void SaveDatesAsInvariantStrings()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
string output = null;
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture)
+ (ctr != dates.Length - 1 ? "|" : "");
}
var sw = new StreamWriter(filenameTxt);
sw.Write(output);
sw.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreDatesAsInvariantStrings()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine("Current Time Zone: {0}",
TimeZoneInfo.Local.DisplayName);
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
StreamReader sr = new StreamReader(filenameTxt);
string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
StringSplitOptions.RemoveEmptyEntries);
sr.Close();
Console.WriteLine("The dates on an {0} system:",
Thread.CurrentThread.CurrentCulture.Name);
foreach (var inputValue in inputValues)
{
DateTime dateValue;
if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind, out dateValue))
{
Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
}
else
{
Console.WriteLine("Cannot parse '{0}'", inputValue);
}
}
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
// '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
// '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
// '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
// '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
// Restored dates...
Public Sub PersistAsInvariantStrings()
SaveDatesAsInvariantStrings()
RestoreDatesAsInvariantStrings()
End Sub
Private Sub SaveDatesAsInvariantStrings()
Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
#1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
#6/2/2014 3:14PM#}
Dim output As String = Nothing
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
For ctr As Integer = 0 To dates.Length - 1
Console.WriteLine(dates(ctr).ToString("f"))
output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
If(ctr <> dates.Length - 1, "|", "")
Next
Dim sw As New StreamWriter(filenameTxt)
sw.Write(output)
sw.Close()
Console.WriteLine("Saved dates...")
End Sub
Private Sub RestoreDatesAsInvariantStrings()
TimeZoneInfo.ClearCachedData()
Console.WriteLine("Current Time Zone: {0}",
TimeZoneInfo.Local.DisplayName)
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Dim sr As New StreamReader(filenameTxt)
Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
sr.Close()
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
For Each inputValue In inputValues
Dim dateValue As Date
If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind, dateValue) Then
Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
Else
Console.WriteLine($"Cannot parse '{inputValue}'")
End If
Next
Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
' Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
' The dates on an en-US system:
' Saturday, June 14, 2014 6:32 AM
' Thursday, July 10, 2014 11:49 PM
' Saturday, January 10, 2015 1:16 AM
' Saturday, December 20, 2014 9:45 PM
' Monday, June 02, 2014 3:14 PM
' Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
' Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
' The dates on an en-GB system:
' '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
' '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
' '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
' '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
' '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
' Restored dates...
Persistenza dei valori come numeri interi
È possibile rendere persistenti una data e un'ora come valore Int64 che rappresenta un numero di tick. In questo caso, non è necessario considerare le impostazioni cultura dei sistemi in cui i valori DateTime vengono resi persistenti e ripristinati.
Per rendere persistente DateTime un valore come numero intero:
- Se i DateTime valori rappresentano singoli istanti nel tempo, convertirli in utc chiamando il ToUniversalTime metodo .
- Recuperare il numero di tick rappresentati dal DateTime valore dalla relativa proprietà Ticks .
Per ripristinare un DateTime valore persistente come numero intero:
- Creare DateTime un'istanza di un nuovo oggetto passando il valore al Int64 DateTime(Int64) costruttore.
- Se il DateTime valore rappresenta un singolo momento, convertirlo dall'ora UTC all'ora locale chiamando il metodo ToLocalTime .
L'esempio seguente rende persistente una matrice di valori come numeri interi in un sistema nel fuso orario del DateTime Pacifico (Stati Uniti). Lo ripristina in un sistema nella zona UTC. Il file che contiene i numeri interi include un valore che indica il numero totale di valori Int32 Int64 che lo seguono immediatamente.
public static void PersistAsIntegers()
{
SaveDatesAsInts();
RestoreDatesAsInts();
}
private static void SaveDatesAsInts()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
var ticks = new long[dates.Length];
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
}
var fs = new FileStream(filenameInts, FileMode.Create);
var bw = new BinaryWriter(fs);
bw.Write(ticks.Length);
foreach (var tick in ticks)
bw.Write(tick);
bw.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreDatesAsInts()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
FileStream fs = new FileStream(filenameInts, FileMode.Open);
BinaryReader br = new BinaryReader(fs);
int items;
DateTime[] dates;
try
{
items = br.ReadInt32();
dates = new DateTime[items];
for (int ctr = 0; ctr < items; ctr++)
{
long ticks = br.ReadInt64();
dates[ctr] = new DateTime(ticks).ToLocalTime();
}
}
catch (EndOfStreamException)
{
Console.WriteLine("File corruption detected. Unable to restore data...");
return;
}
catch (IOException)
{
Console.WriteLine("Unspecified I/O error. Unable to restore data...");
return;
}
// Thrown during array initialization.
catch (OutOfMemoryException)
{
Console.WriteLine("File corruption detected. Unable to restore data...");
return;
}
finally
{
br.Close();
}
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
foreach (var value in dates)
Console.WriteLine(value.ToString("f"));
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// 14 June 2014 14:32
// 11 July 2014 07:49
// 10 January 2015 09:16
// 21 December 2014 05:45
// 02 June 2014 23:14
// Restored dates...
Public Sub PersistAsIntegers()
SaveDatesAsIntegers()
RestoreDatesAsIntegers()
End Sub
Private Sub SaveDatesAsIntegers()
Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
#1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
#6/2/2014 3:14PM#}
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
Dim ticks(dates.Length - 1) As Long
For ctr As Integer = 0 To dates.Length - 1
Console.WriteLine(dates(ctr).ToString("f"))
ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
Next
Dim fs As New FileStream(filenameInts, FileMode.Create)
Dim bw As New BinaryWriter(fs)
bw.Write(ticks.Length)
For Each tick In ticks
bw.Write(tick)
Next
bw.Close()
Console.WriteLine("Saved dates...")
End Sub
Private Sub RestoreDatesAsIntegers()
TimeZoneInfo.ClearCachedData()
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Dim fs As New FileStream(filenameInts, FileMode.Open)
Dim br As New BinaryReader(fs)
Dim items As Integer
Dim dates As DateTime()
Try
items = br.ReadInt32()
ReDim dates(items - 1)
For ctr As Integer = 0 To items - 1
Dim ticks As Long = br.ReadInt64()
dates(ctr) = New DateTime(ticks).ToLocalTime()
Next
Catch e As EndOfStreamException
Console.WriteLine("File corruption detected. Unable to restore data...")
Exit Sub
Catch e As IOException
Console.WriteLine("Unspecified I/O error. Unable to restore data...")
Exit Sub
Catch e As OutOfMemoryException 'Thrown in array initialization.
Console.WriteLine("File corruption detected. Unable to restore data...")
Exit Sub
Finally
br.Close()
End Try
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
For Each value In dates
Console.WriteLine(value.ToString("f"))
Next
Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
' Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
' The dates on an en-US system:
' Saturday, June 14, 2014 6:32 AM
' Thursday, July 10, 2014 11:49 PM
' Saturday, January 10, 2015 1:16 AM
' Saturday, December 20, 2014 9:45 PM
' Monday, June 02, 2014 3:14 PM
' Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
' Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
' The dates on an en-GB system:
' 14 June 2014 14:32
' 11 July 2014 07:49
' 10 January 2015 09:16
' 21 December 2014 05:45
' 02 June 2014 23:14
' Restored dates...
Serializzazione di valori DateTime
È possibile rendere persistenti i valori tramite la serializzazione in un flusso o in un DateTime file e quindi ripristinarli tramite deserializzazione. DateTime I dati vengono serializzati in un formato di oggetto specificato. Gli oggetti vengono ripristinati quando vengono deserializzati. Un formattatore o un serializzatore, ad XmlSerializer esempio o , gestisce il processo di BinaryFormatter serializzazione e deserializzazione. Per altre informazioni sulla serializzazione e sui tipi di serializzazione supportati dal .NET Framework, vedere Serializzazione.
Nell'esempio seguente viene utilizzata XmlSerializer la classe per serializzare e deserializzare DateTime i valori. I valori rappresentano tutti i giorni dell'anno bisestile nel ventunesimo secolo. L'output rappresenta il risultato se l'esempio viene eseguito in un sistema le cui impostazioni cultura correnti sono l'inglese (Gran Francia). Poiché l'oggetto stesso è stato deserializzato, il codice non deve gestire le differenze culturali nei formati DateTime di data e ora.
public static void PersistAsXML()
{
// Serialize the data.
var leapYears = new List<DateTime>();
for (int year = 2000; year <= 2100; year += 4)
{
if (DateTime.IsLeapYear(year))
leapYears.Add(new DateTime(year, 2, 29));
}
DateTime[] dateArray = leapYears.ToArray();
var serializer = new XmlSerializer(dateArray.GetType());
TextWriter sw = new StreamWriter(filenameXml);
try
{
serializer.Serialize(sw, dateArray);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.InnerException.Message);
}
finally
{
if (sw != null) sw.Close();
}
// Deserialize the data.
DateTime[] deserializedDates;
using (var fs = new FileStream(filenameXml, FileMode.Open))
{
deserializedDates = (DateTime[])serializer.Deserialize(fs);
}
// Display the dates.
Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
int nItems = 0;
foreach (var dat in deserializedDates)
{
Console.Write($" {dat:d} ");
nItems++;
if (nItems % 5 == 0)
Console.WriteLine();
}
}
// The example displays the following output:
// Leap year days from 2000-2100 on an en-GB system:
// 29/02/2000 29/02/2004 29/02/2008 29/02/2012 29/02/2016
// 29/02/2020 29/02/2024 29/02/2028 29/02/2032 29/02/2036
// 29/02/2040 29/02/2044 29/02/2048 29/02/2052 29/02/2056
// 29/02/2060 29/02/2064 29/02/2068 29/02/2072 29/02/2076
// 29/02/2080 29/02/2084 29/02/2088 29/02/2092 29/02/2096
Public Sub PersistAsXml()
' Serialize the data.
Dim leapYears As New List(Of DateTime)()
For year As Integer = 2000 To 2100 Step 4
If Date.IsLeapYear(year) Then
leapYears.Add(New Date(year, 2, 29))
End If
Next
Dim dateArray As DateTime() = leapYears.ToArray()
Dim serializer As New XmlSerializer(dateArray.GetType())
Dim sw As TextWriter = New StreamWriter(filenameXml)
Try
serializer.Serialize(sw, dateArray)
Catch e As InvalidOperationException
Console.WriteLine(e.InnerException.Message)
Finally
If sw IsNot Nothing Then sw.Close()
End Try
' Deserialize the data.
Dim deserializedDates As Date()
Using fs As New FileStream(filenameXml, FileMode.Open)
deserializedDates = CType(serializer.Deserialize(fs), Date())
End Using
' Display the dates.
Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
Dim nItems As Integer
For Each dat In deserializedDates
Console.Write($" {dat:d} ")
nItems += 1
If nItems Mod 5 = 0 Then Console.WriteLine()
Next
End Sub
' The example displays the following output:
' Leap year days from 2000-2100 on an en-GB system:
' 29/02/2000 29/02/2004 29/02/2008 29/02/2012 29/02/2016
' 29/02/2020 29/02/2024 29/02/2028 29/02/2032 29/02/2036
' 29/02/2040 29/02/2044 29/02/2048 29/02/2052 29/02/2056
' 29/02/2060 29/02/2064 29/02/2068 29/02/2072 29/02/2076
' 29/02/2080 29/02/2084 29/02/2088 29/02/2092 29/02/2096
L'esempio precedente non include informazioni sull'ora. Se un valore rappresenta un momento e viene espresso come ora locale, convertirlo dall'ora locale all'ora UTC prima di DateTime serializzarlo chiamando il metodo ToUniversalTime . Dopo la deserializzazione, convertirlo dall'ora UTC all'ora locale chiamando il ToLocalTime metodo . Nell'esempio seguente viene utilizzata la classe per serializzare i dati in un sistema nel fuso orario standard del Pacifico degli Stati Uniti e BinaryFormatter per deserializzarlo in un sistema nella zona standard centrale degli Stati DateTime Uniti.
public static void PersistBinary()
{
SaveDatesBinary();
RestoreDatesBinary();
}
private static void SaveDatesBinary()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
var fs = new FileStream(filenameBin, FileMode.Create);
var bin = new BinaryFormatter();
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
dates[ctr] = dates[ctr].ToUniversalTime();
}
bin.Serialize(fs, dates);
fs.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreDatesBinary()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
FileStream fs = new FileStream(filenameBin, FileMode.Open);
BinaryFormatter bin = new BinaryFormatter();
var dates = (DateTime[])bin.Deserialize(fs);
fs.Close();
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
foreach (var value in dates)
Console.WriteLine(value.ToLocalTime().ToString("f"));
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC-6:00) Central Time (US & Canada)
// The dates on an en-GB system:
// 14 June 2014 08:32
// 11 July 2014 01:49
// 10 January 2015 03:16
// 20 December 2014 23:45
// 02 June 2014 17:14
// Restored dates...
Public Sub PersistBinary()
SaveDatesBinary()
RestoreDatesBinary()
End Sub
Private Sub SaveDatesBinary()
Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
#1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
#6/2/2014 3:14PM#}
Dim fs As New FileStream(filenameBin, FileMode.Create)
Dim bin As New BinaryFormatter()
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
For ctr As Integer = 0 To dates.Length - 1
Console.WriteLine(dates(ctr).ToString("f"))
dates(ctr) = dates(ctr).ToUniversalTime()
Next
bin.Serialize(fs, dates)
fs.Close()
Console.WriteLine("Saved dates...")
End Sub
Private Sub RestoreDatesBinary()
TimeZoneInfo.ClearCachedData()
Console.WriteLine("Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Dim fs As New FileStream(filenameBin, FileMode.Open)
Dim bin As New BinaryFormatter()
Dim dates As DateTime() = DirectCast(bin.Deserialize(fs), Date())
fs.Close()
Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
For Each value In dates
Console.WriteLine(value.ToLocalTime().ToString("f"))
Next
Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
' Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
' The dates on an en-US system:
' Saturday, June 14, 2014 6:32 AM
' Thursday, July 10, 2014 11:49 PM
' Saturday, January 10, 2015 1:16 AM
' Saturday, December 20, 2014 9:45 PM
' Monday, June 02, 2014 3:14 PM
' Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
' Current Time Zone: (UTC-6:00) Central Time (US & Canada)
' The dates on an en-GB system:
' 14 June 2014 08:32
' 11 July 2014 01:49
' 10 January 2015 03:16
' 20 December 2014 11:45
' 02 June 2014 17:14
' Restored dates...
Serializzazione dei dati DateTime e del fuso orario
Tutti gli esempi precedenti presupponeno che DateTime i valori siano espressi come ora locale. Il codice ha convertito i valori tra l'ora UTC e l'ora locale in modo che riflettano lo stesso momento nel sistema di origine e di destinazione. DateTime I valori possono anche riflettere momenti di tempo in un fuso orario diverso da locale e UTC. Poiché la struttura non supporta il fuso orario, è necessario serializzare sia il valore che l'oggetto DateTime che ne rappresenta il fuso DateTime TimeZoneInfo orario. Creare un tipo i cui campi includono sia DateTime il valore che il relativo fuso orario. Nell'esempio seguente viene definita una DateWithTimeZone struttura .
using System;
namespace DateTimeExtensions
{
[Serializable]
public struct DateWithTimeZone
{
private TimeZoneInfo tz;
private DateTime dt;
public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
{
dt = dateValue;
tz = timeZone ?? TimeZoneInfo.Local;
}
public TimeZoneInfo TimeZone
{
get { return (tz); }
set { tz = value; }
}
public DateTime DateTime
{
get { return (dt); }
set { dt = value; }
}
}
}
Namespace DateTimeExtensions
<Serializable> Public Structure DateWithTimeZone
Private tz As TimeZoneInfo
Private dt As DateTime
Public Sub New(dateValue As DateTime, timeZone As TimeZoneInfo)
dt = dateValue
tz = If(timeZone, TimeZoneInfo.Local)
End Sub
Public Property TimeZone As TimeZoneInfo
Get
Return tz
End Get
Set
tz = Value
End Set
End Property
Public Property DateTime As Date
Get
Return dt
End Get
Set
dt = Value
End Set
End Property
End Structure
End Namespace
Importante
La DateWithTimeZone struttura viene utilizzata nei due esempi successivi, che serializzano e deserializzano una matrice di oggetti DateWithTimeZone . È possibile visualizzare l'origine per l'intero set di esempi di questo articolo in Visual Basic o C# dal repository docs in GitHub.
Usando la struttura DateWithTimeZone , è quindi possibile rendere persistenti data e ora insieme alle informazioni sul fuso orario. Nell'esempio seguente viene BinaryFormatter utilizzata la classe per serializzare una matrice di oggetti DateWithTimeZone .
public static void SaveDateWithTimeZone()
{
DateWithTimeZone[] dates = { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),
TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0),
TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),
TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0),
TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
var fs = new FileStream(@".\Schedule.bin", FileMode.Create);
var formatter = new BinaryFormatter();
try
{
formatter.Serialize(fs, dates);
// Display dates.
foreach (var date in dates)
{
TimeZoneInfo tz = date.TimeZone;
Console.WriteLine($"{date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
}
}
catch (SerializationException e)
{
Console.WriteLine($"Serialization failed. Reason: {e.Message}");
}
finally
{
if (fs != null) fs.Close();
}
}
// The example displays the following output:
// 8/9/2014 7:30:00 PM Eastern Daylight Time
// 8/15/2014 7:00:00 PM Pacific Daylight Time
// 8/22/2014 7:30:00 PM Eastern Daylight Time
// 8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub SaveDateWithTimeZone()
Dim dates As DateWithTimeZone() = {New DateWithTimeZone(#8/9/2014 7:30PM#,
TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
New DateWithTimeZone(#8/15/2014 7:00PM#,
TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
New DateWithTimeZone(#8/22/2014 7:30PM#,
TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
New DateWithTimeZone(#8/28/2014 7:00PM#,
TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"))}
Dim fs As New FileStream(".\Schedule.bin", FileMode.Create)
Dim formatter As New BinaryFormatter()
Try
formatter.Serialize(fs, dates)
Catch e As SerializationException
Console.WriteLine($"Serialization failed. Reason: {e.Message}")
Finally
If fs IsNot Nothing Then fs.Close()
End Try
' Display dates.
For Each dateInfo In dates
Dim tz As TimeZoneInfo = dateInfo.TimeZone
Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
Next
End Sub
' The example displays the following output:
' 8/9/2014 7:30:00 PM Eastern Daylight Time
' 8/15/2014 7:00:00 PM Pacific Daylight Time
' 8/22/2014 7:30:00 PM Eastern Daylight Time
' 8/28/2014 7:00:00 PM Eastern Daylight Time
Nell'esempio seguente viene quindi chiamato BinaryFormatter.Deserialize il metodo per deserializzarlo.
public static void RestoreDateWithTimeZone()
{
const string filename = @".\Schedule.bin";
FileStream fs;
if (File.Exists(filename))
{
fs = new FileStream(filename, FileMode.Open);
}
else
{
Console.WriteLine("Unable to find file to deserialize.");
return;
}
var formatter = new BinaryFormatter();
DateWithTimeZone[] dates;
try
{
dates = (DateWithTimeZone[])formatter.Deserialize(fs);
// Display dates.
foreach (var date in dates)
{
TimeZoneInfo tz = date.TimeZone;
Console.WriteLine($"{ date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
}
}
catch (SerializationException e)
{
Console.WriteLine($"Deserialization failed. Reason: {e.Message}");
}
finally
{
if (fs != null) fs.Close();
}
}
// The example displays the following output:
// 8/9/2014 7:30:00 PM Eastern Daylight Time
// 8/15/2014 7:00:00 PM Pacific Daylight Time
// 8/22/2014 7:30:00 PM Eastern Daylight Time
// 8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub RestoreDateWithTimeZone()
Dim fs As FileStream
If File.Exists(filename) Then
fs = New FileStream(filename, FileMode.Open)
Else
Console.WriteLine("Unable to find file to deserialize.")
Exit Sub
End If
Dim formatter As New BinaryFormatter()
Dim dates As DateWithTimeZone ()= Nothing
Try
dates = DirectCast(formatter.Deserialize(fs), DateWithTimeZone())
' Display dates.
For Each dateInfo In dates
Dim tz As TimeZoneInfo = dateInfo.TimeZone
Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
Next
Catch e As SerializationException
Console.WriteLine("Deserialization failed. Reason: {e.Message}")
Finally
If fs IsNot Nothing Then fs.Close()
End Try
End Sub
' The example displays the following output:
' 8/9/2014 7:30:00 PM Eastern Daylight Time
' 8/15/2014 7:00:00 PM Pacific Daylight Time
' 8/22/2014 7:30:00 PM Eastern Daylight Time
' 8/28/2014 7:00:00 PM Eastern Daylight Time
DateTime e TimeSpan
I DateTime tipi di valore e TimeSpan differiscono per il fatto che un oggetto DateTime rappresenta un istante nel tempo, mentre un TimeSpan oggetto rappresenta un intervallo di tempo. È possibile sottrarre un'istanza DateTime di da un'altra per ottenere un TimeSpan oggetto che rappresenta l'intervallo di tempo tra di esse. Oppure è possibile aggiungere un positivo TimeSpan all'oggetto DateTime corrente per ottenere un valore che rappresenta una data DateTime futura.
È possibile aggiungere o sottrarre un intervallo di tempo da un DateTime oggetto . Gli intervalli di tempo possono essere negativi o positivi e possono essere espressi in unità come tick, secondi o come TimeSpan oggetto.
Confronto per l'uguaglianza all'interno della tolleranza
I confronti di uguaglianza per DateTime i valori sono esatti. Ciò significa che due valori devono essere espressi come lo stesso numero di tick da considerare uguali. Questa precisione è spesso superflua o persino errata per molte applicazioni. Spesso si vuole verificare se gli DateTime oggetti sono approssimativamente uguali.
Nell'esempio seguente viene illustrato come confrontare valori approssimativamente DateTime equivalenti. Accetta un piccolo margine di differenza quando vengono dichiarati uguali.
public static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
{
long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds % frequencyInSeconds;
delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
return Math.Abs(delta) < windowInSeconds;
}
public static void TestRoughlyEquals()
{
int window = 10;
int freq = 60 * 60 * 2; // 2 hours;
DateTime d1 = DateTime.Now;
DateTime d2 = d1.AddSeconds(2 * window);
DateTime d3 = d1.AddSeconds(-2 * window);
DateTime d4 = d1.AddSeconds(window / 2);
DateTime d5 = d1.AddSeconds(-window / 2);
DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);
Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}");
}
// The example displays output similar to the following:
// d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
windowInSeconds As Integer,
frequencyInSeconds As Integer) As Boolean
Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
Mod frequencyInSeconds
If delta > windowInSeconds Then
delta = frequencyInSeconds - delta
End If
Return Math.Abs(delta) < windowInSeconds
End Function
Public Shared Sub TestRoughlyEquals()
Dim window As Integer = 10
Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
Dim d1 As DateTime = DateTime.Now
Dim d2 As DateTime = d1.AddSeconds(2 * window)
Dim d3 As DateTime = d1.AddSeconds(-2 * window)
Dim d4 As DateTime = d1.AddSeconds(window / 2)
Dim d5 As DateTime = d1.AddSeconds(-window / 2)
Dim d6 As DateTime = d1.AddHours(2).AddSeconds(2 * window)
Dim d7 As DateTime = d1.AddHours(2).AddSeconds(-2 * window)
Dim d8 As DateTime = d1.AddHours(2).AddSeconds(window / 2)
Dim d9 As DateTime = d1.AddHours(2).AddSeconds(-window / 2)
Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' The example displays output similar to the following:
' d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
' d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
' d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
Considerazioni sull'interoperabilità COM
Un DateTime valore che viene trasferito a un'applicazione COM, quindi viene trasferito nuovamente a un'applicazione gestita, viene detto round trip. Tuttavia, un DateTime valore che specifica solo un'ora non esegue il round trip come previsto.
Se si arrotonda solo un'ora, ad esempio le 15.00, la data e l'ora finali sono il 30 dicembre 1899 C.E. alle 15:00 invece dell'1 gennaio 0001 C.E. alle 15:00 I .NET Framework e COM presuppongono una data predefinita quando viene specificata solo un'ora. Tuttavia, il sistema COM presuppone una data di base del 30 dicembre 1899 C.E., mentre il .NET Framework presuppone una data di base del 1° gennaio 0001 C.E.
Quando viene passato solo un tempo dal .NET Framework a COM, viene eseguita un'elaborazione speciale che converte l'ora nel formato usato da COM. Quando viene passata solo un'ora da COM al .NET Framework, non viene eseguita alcuna elaborazione speciale perché ciò potrebbe danneggiare le date e le ore legittime il 30 dicembre 1899 o prima di dicembre 1899. Se una data inizia il round trip da COM, .NET Framework e COM mantengono la data.
Il comportamento del .NET Framework e COM indica che se l'applicazione arrotonda un oggetto che specifica solo un'ora, l'applicazione deve ricordarsi di modificare o ignorare la data errata dell'oggetto DateTime DateTime finale.
Costruttori
| DateTime(Int32, Int32, Int32) |
Inizializza una nuova istanza della struttura DateTime su anno, mese e giorno specificati. |
| DateTime(Int32, Int32, Int32, Calendar) |
Inizializza una nuova istanza della struttura DateTime su anno, mese e giorno indicati per il calendario specificato. |
| DateTime(Int32, Int32, Int32, Int32, Int32, Int32) |
Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto e secondo specificati. |
| DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar) |
Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto e secondo determinati per il calendario specificato. |
| DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind) |
Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo e ora UTC (Coordinated Universal Time) oppure ora locale specificati. |
| DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32) |
Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo e millisecondo specificati. |
| DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar) |
Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo e millisecondo determinati per il calendario specificato. |
| DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind) |
Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo, millisecondo e ora UTC (Coordinated Universal Time) oppure ora locale specificati per il calendario indicato. |
| DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind) |
Inizializza una nuova istanza della struttura DateTime su anno, mese, giorno, ora, minuto, secondo, millisecondo e ora UTC (Coordinated Universal Time) oppure ora locale specificati. |
| DateTime(Int64) |
Inizializza una nuova istanza della struttura DateTime su un numero di tick specificato. |
| DateTime(Int64, DateTimeKind) |
Inizializza una nuova istanza della struttura DateTime su un numero specificato di tick e sull'ora UTC (Coordinated Universal Time) oppure sull'ora locale. |
Campi
| MaxValue |
Rappresenta il valore massimo possibile di DateTime. Questo campo è di sola lettura. |
| MinValue |
Rappresenta il valore più piccolo possibile di DateTime. Questo campo è di sola lettura. |
| UnixEpoch |
Il valore di questa costante è equivalente a 00:00:00.0000000 UTC, 1 gennaio 1970, nel calendario gregoriano. UnixEpoch definisce il momento in cui l'ora UNIX è uguale a 0. |
Proprietà
| Date |
Ottiene il componente di data dell'istanza. |
| Day |
Ottiene il giorno del mese rappresentato dall'istanza. |
| DayOfWeek |
Ottiene il giorno della settimana rappresentato dall'istanza. |
| DayOfYear |
Ottiene il giorno dell'anno rappresentato dall'istanza. |
| Hour |
Ottiene il componente di ora della data rappresentata dall'istanza. |
| Kind |
Ottiene un valore che indica se l'ora rappresentata dall'istanza si basa sull'ora locale, sull'ora UTC (Coordinated Universal Time) o su nessuna delle due. |
| Millisecond |
Ottiene il componente di millisecondi della data rappresentata dall'istanza. |
| Minute |
Ottiene il componente di minuti della data rappresentata dall'istanza. |
| Month |
Ottiene il componente di mese della data rappresentata dall'istanza. |
| Now |
Ottiene un oggetto DateTime impostato su data e ora correnti sul computer, espresso come ora locale. |
| Second |
Ottiene il componente di secondi della data rappresentata dall'istanza. |
| Ticks |
Ottiene il numero di tick che rappresentano data e ora dell'istanza. |
| TimeOfDay |
Ottiene l'ora del giorno per l'istanza. |
| Today |
Ottiene la data corrente. |
| UtcNow |
Ottiene un oggetto DateTime impostato su data e ora correnti sul computer, espresso come ora UTC (Coordinated Universal Time). |
| Year |
Ottiene il componente dell'anno della data rappresentata dall'istanza. |
Metodi
| Add(TimeSpan) |
Restituisce un nuovo oggetto DateTime che aggiunge il valore dell'oggetto TimeSpan specificato al valore di questa istanza. |
| AddDays(Double) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di giorni al valore di questa istanza. |
| AddHours(Double) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di ore al valore di questa istanza. |
| AddMilliseconds(Double) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di millisecondi al valore di questa istanza. |
| AddMinutes(Double) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di minuti al valore di questa istanza. |
| AddMonths(Int32) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di mesi al valore di questa istanza. |
| AddSeconds(Double) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di secondi al valore di questa istanza. |
| AddTicks(Int64) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di tick al valore di questa istanza. |
| AddYears(Int32) |
Restituisce un nuovo oggetto DateTime che aggiunge il numero specificato di anni al valore di questa istanza. |
| Compare(DateTime, DateTime) |
Confronta due istanze di DateTime e restituisce un intero che indica se la prima istanza è precedente, uguale o successiva alla seconda istanza. |
| CompareTo(DateTime) |
Confronta il valore di questa istanza con un valore DateTime specificato e restituisce un intero che indica se l'istanza è precedente, uguale o successiva al valore DateTime specificato. |
| CompareTo(Object) |
Confronta il valore di questa istanza con un oggetto specificato contenente un valore DateTime specificato e restituisce un intero che indica se l'istanza è precedente, uguale o successiva al valore DateTime specificato. |
| DaysInMonth(Int32, Int32) |
Restituisce il numero di giorni del mese specificato dell'anno specificato. |
| Equals(DateTime) |
Restituisce un valore che indica se il valore di questa istanza è uguale al valore dell'istanza di DateTime specificata. |
| Equals(DateTime, DateTime) |
Restituisce un valore che indica se due istanze di DateTime presentano lo stesso valore di data e ora. |
| Equals(Object) |
Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato. |
| FromBinary(Int64) |
Deserializza un valore binario a 64 bit e ricrea un oggetto originale DateTime serializzato. |
| FromFileTime(Int64) |
Converte l'ora specificata di un file di Windows in un'ora locale equivalente. |
| FromFileTimeUtc(Int64) |
Converte l'ora di un file di Windows specificata in un'ora UTC equivalente. |
| FromOADate(Double) |
Restituisce un oggetto DateTime equivalente alla data di automazione OLE specificata. |
| GetDateTimeFormats() |
Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dagli identificatori di formato di data e ora standard. |
| GetDateTimeFormats(Char) |
Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dall'identificatore di formato di data e ora standard specificato. |
| GetDateTimeFormats(Char, IFormatProvider) |
Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dall'identificatore di formato di data e ora standard e dalle informazioni di formattazione specifiche delle impostazioni cultura. |
| GetDateTimeFormats(IFormatProvider) |
Converte il valore dell'istanza in tutte le rappresentazioni di stringa supportate dagli identificatori di formato di data e ora standard e dalle informazioni di formattazione relative alle impostazioni cultura specificate. |
| GetHashCode() |
Restituisce il codice hash per l'istanza. |
| GetTypeCode() | |
| IsDaylightSavingTime() |
Indica se l'istanza dell'oggetto DateTime è compresa nell'intervallo l'ora legale del fuso orario corrente. |
| IsLeapYear(Int32) |
Restituisce un'indicazione che informa se l'anno specificato è bisestile. |
| Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) |
Converte un intervallo di memoria che contiene la rappresentazione stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione. |
| Parse(String) |
Converte la rappresentazione di stringa di una data e di un'ora DateTime nell'equivalente usando le convenzioni delle impostazioni cultura correnti. |
| Parse(String, IFormatProvider) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo DateTime equivalente usando le informazioni sul formato relative alle impostazioni cultura specificate. |
| Parse(String, IFormatProvider, DateTimeStyles) |
Converte la rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione. |
| ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) |
Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione. |
| ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) |
Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice specificata di formati, informazioni sul formato specifiche delle impostazioni cultura e stile. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione. |
| ParseExact(String, String, IFormatProvider) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo oggetto DateTime equivalente usando il formato specificato e le informazioni sul formato relative alle impostazioni cultura specificate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. |
| ParseExact(String, String, IFormatProvider, DateTimeStyles) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione. |
| ParseExact(String, String[], IFormatProvider, DateTimeStyles) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione. |
| SpecifyKind(DateTime, DateTimeKind) |
Crea un nuovo oggetto DateTime che ha lo stesso numero di tick dell'oggetto DateTime specificato, ma viene definito come ora locale, ora UTC (Coordinated Universal Time) o nessuna delle due, a seconda di quanto indicato nel valore di DateTimeKind specificato. |
| Subtract(DateTime) |
Restituisce un nuovo elemento TimeSpan che sottrae la data e l'ora specificate dal valore dell'istanza. |
| Subtract(TimeSpan) |
Restituisce un nuovo elemento DateTime che sottrae la durata specificata dal valore dell'istanza. |
| ToBinary() |
Serializza l'oggetto DateTime corrente in un valore binario a 64 bit che può essere quindi usato per ricreare l'oggetto DateTime. |
| ToFileTime() |
Converte il valore dell'oggetto DateTime corrente in un'ora di un file di Windows. |
| ToFileTimeUtc() |
Converte il valore dell'oggetto DateTime corrente in un'ora di un file di Windows. |
| ToLocalTime() |
Converte il valore dell'oggetto DateTime corrente in un'ora locale. |
| ToLongDateString() |
Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa della data estesa. |
| ToLongTimeString() |
Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa dell'ora estesa. |
| ToOADate() |
Converte il valore dell'istanza nella data di automazione OLE equivalente. |
| ToShortDateString() |
Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa della data breve. |
| ToShortTimeString() |
Converte il valore dell'oggetto DateTime corrente nell'equivalente rappresentazione di stringa dell'ora breve. |
| ToString() |
Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando le convenzioni di formattazione delle impostazioni cultura. |
| ToString(IFormatProvider) |
Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando le informazioni sul formato relative alle impostazioni cultura specificate. |
| ToString(String) |
Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando il formato specificato e le convenzioni di formattazione delle impostazioni cultura. |
| ToString(String, IFormatProvider) |
Converte il valore dell'oggetto DateTime corrente nella rappresentazione di stringa equivalente, usando il formato specificato e le informazioni sul formato specifiche delle impostazioni cultura indicate. |
| ToUniversalTime() |
Converte il valore dell'oggetto DateTime corrente nell'ora UTC (Coordinated Universal Time). |
| TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Tenta di formattare il valore dell'istanza datetime corrente nell'intervallo di caratteri specificato. |
| TryParse(ReadOnlySpan<Char>, DateTime) |
Converte l'intervallo di caratteri specificato di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime) |
Converte una rappresentazione in forma di intervallo di una data e di un'ora nell'equivalente DateTime usando le informazioni sul formato specifico delle impostazioni cultura e lo stile di formattazione specifici, quindi restituisce un valore che indica se la conversione è stata eseguita correttamente. |
| TryParse(String, DateTime) |
Converte la rappresentazione di stringa specificata di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente. |
| TryParse(String, IFormatProvider, DateTimeStyles, DateTime) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'equivalente DateTime usando le informazioni sul formato specifico delle impostazioni cultura e lo stile di formattazione specifici, quindi restituisce un valore che indica se la conversione è stata eseguita correttamente. |
| TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime) |
Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente. |
| TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime) |
Converte l'intervallo di caratteri specificato di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente. |
| TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente. |
| TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) |
Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente. |
Operatori
| Addition(DateTime, TimeSpan) |
Aggiunge un determinato intervallo di tempo a una data e a un'ora specificate, producendo una data e un'ora nuove. |
| Equality(DateTime, DateTime) |
Determina se due istanze specificate dell'oggetto DateTime sono uguali. |
| GreaterThan(DateTime, DateTime) |
Determina se un DateTime specificato è successivo a un altro DateTime specificato. |
| GreaterThanOrEqual(DateTime, DateTime) |
Determina se un oggetto DateTime specificato rappresenta una data e ora uguali o successive a un altro oggetto DateTime specificato. |
| Inequality(DateTime, DateTime) |
Determina se due istanze specificate dell'oggetto DateTime non sono uguali. |
| LessThan(DateTime, DateTime) |
Determina se un oggetto DateTime specificato è precedente a un altro oggetto DateTime specificato. |
| LessThanOrEqual(DateTime, DateTime) |
Determina se un oggetto DateTime specificato rappresenta una data e ora uguali o precedenti a un altro oggetto DateTime specificato. |
| Subtraction(DateTime, DateTime) |
Sottrae una data e un'ora specificate da un'altra data e un'altra ora specificate e restituisce un intervallo di tempo. |
| Subtraction(DateTime, TimeSpan) |
Sottrae un intervallo di tempo specificato da una data e un'ora specificate e restituisce una data e un'ora nuove. |
Implementazioni dell'interfaccia esplicita
| IComparable.CompareTo(Object) |
Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento. |
| IConvertible.GetTypeCode() |
Restituisce l'oggetto TypeCode per questa istanza. |
| IConvertible.ToBoolean(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToByte(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToChar(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToDateTime(IFormatProvider) |
Restituisce l'attuale oggetto DateTime. |
| IConvertible.ToDecimal(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToDouble(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToInt16(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToInt32(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToInt64(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToSByte(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToSingle(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToType(Type, IFormatProvider) |
Converte l'oggetto DateTime corrente in un oggetto di un tipo specificato. |
| IConvertible.ToUInt16(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToUInt32(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToUInt64(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di usare questo metodo genera un'eccezione InvalidCastException. |
| ISerializable.GetObjectData(SerializationInfo, StreamingContext) |
Compila un oggetto SerializationInfo con i dati necessari per serializzare l'oggetto DateTime corrente. |
Si applica a
Thread safety
Tutti i membri di questo tipo sono thread-safe. I membri che sembrano modificare lo stato dell'istanza restituiscono effettivamente una nuova istanza inizializzata con il nuovo valore. Come per qualsiasi altro tipo, la lettura e la scrittura in una variabile condivisa che contiene un'istanza di questo tipo devono essere protette da un blocco per garantire la thread safety.