Struct System.DateTime
Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.
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 sui test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento dell'era, vedere Preparare l'applicazione per il cambiamento dell'era giapponese. Per le funzionalità di .NET che supportano calendari con più ere e per le procedure consigliate quando si usano calendari che supportano più ere, vedere Uso delle era.
Panoramica
Il DateTime tipo valore rappresenta date e ore con valori compresi tra le 00:00:00 (mezzanotte), il 1° gennaio 0001 Anno Domini (Common Era) fino alle 11:59:59:59, 31 dicembre 99999 A.D. (C.E.) nel calendario gregoriano.
I valori temporali vengono misurati in unità di 100 nanosecondi denominate tick. Una data specifica è il numero di tick dalle 12:00 mezzanotte, 1 gennaio 0001 A.D. (C.E.) nel GregorianCalendar calendario. Il numero esclude i tick che verrebbero aggiunti da secondi intercalari. Ad esempio, un valore tick pari a 312413760000000000L 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 da convertire in un altro intervallo di tempo, ad esempio minuti o secondi, è necessario usare la TimeSpan.TicksPerDaycostante , TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, o TimeSpan.TicksPerMillisecond per eseguire la conversione. Ad esempio, per aggiungere il numero di secondi rappresentato da un numero specificato di tick al Second componente di un DateTime valore, è possibile usare l'espressione dateValue.Second + nTicks/Timespan.TicksPerSecond.
È possibile visualizzare l'origine per l'intero set di esempi di questo articolo in Visual Basic, F# o C#.
Nota
Un'alternativa alla struttura per l'utilizzo DateTime dei valori di data e ora in determinati fusi orari è la DateTimeOffset struttura. La DateTimeOffset struttura archivia le informazioni di data e ora in un campo privato DateTime e il numero di minuti in base ai quali tale data e ora differisce rispetto all'ora UTC in un campo privato Int16 . Ciò consente a un DateTimeOffset valore di riflettere l'ora in un determinato fuso orario, mentre un DateTime valore può riflettere in modo univoco solo l'ora UTC e l'ora del fuso orario locale. Per informazioni su quando usare la DateTime struttura o la DateTimeOffset struttura quando si usano valori di data e ora, vedere Scelta tra DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.
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
- Sintassi di Visual Basic per inizializzare una data e un'ora
Formattare DateTime gli oggetti come esempi di stringhe
- Usare il formato di data e 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 un'ora di data usando lo standard ISO 8601 per i servizi Web
Analizzare le stringhe come DateTime esempi di oggetti
- Usare
ParseoTryParseper convertire una stringa in una data e un'ora - Usare
ParseExactoTryParseExactper convertire una stringa in un formato noto - Eseguire la conversione dalla rappresentazione di stringa ISO 8601 a una data e un'ora
DateTime esempi di risoluzione
- Esplorare la risoluzione dei valori di data e ora
- Confronto dell'uguaglianza all'interno di una tolleranza
Esempi di 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 delle impostazioni cultura specifiche
- Accesso alle proprietà di data e ora usando il calendario delle impostazioni cultura specifiche
- Recupero della settimana dell'anno utilizzando calendari specifici delle impostazioni cultura
Esempi di persistenza
- Rendere persistenti i valori di data e ora come stringhe nel fuso orario locale
- Rendere persistenti i valori di data e ora come stringhe in un formato invariante delle impostazioni cultura e dell'ora
- Rendere persistenti i valori di data e ora come numeri interi
- Rendere persistenti i valori di data e ora usando
XmlSerializer
Inizializzare un oggetto DateTime
È possibile assegnare un valore iniziale a un nuovo DateTime 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 delle funzionalità del linguaggio specifiche di Visual Basic per creare un'istanza di .
DateTime
I frammenti di codice seguenti mostrano esempi di ognuno di essi.
Richiamare costruttori
Chiamare uno degli overload del DateTime costruttore che specifica gli elementi del valore di data e ora , ad esempio anno, mese e giorno o il numero di tick. Il codice seguente crea una data specifica usando il costruttore che specifica l'anno, il DateTime mese, il giorno, l'ora, il minuto e il 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);
let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"
Richiamare il DateTime costruttore implicito senza parametri della struttura quando si desidera inizializzare un DateTime valore predefinito. Per informazioni dettagliate sul costruttore implicito senza parametri di un tipo valore, vedere Tipi valore. Alcuni compilatori supportano anche la dichiarazione di un DateTime valore senza assegnarvi esplicitamente un valore. La creazione di un valore senza inizializzazione esplicita comporta anche il valore predefinito. Nell'esempio seguente viene illustrato il DateTime costruttore implicito senza parametri in C# e Visual Basic, nonché una DateTime dichiarazione senza assegnazione 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));
let dat1 = DateTime()
// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"
// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"
Assegnare un valore calcolato
È possibile assegnare all'oggetto DateTime un valore di data e ora restituito da una proprietà o un metodo. L'esempio seguente assegna la data e l'ora correnti, la data e l'ora UTC correnti 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;
let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today
Analizzare una stringa che rappresenta un valore DateTime
I Parsemetodi , TryParseParseExact, e TryParseExact converteno tutte una stringa nel valore di data e ora equivalente. Negli esempi seguenti vengono usati i Parse metodi e ParseExact per analizzare una stringa e convertirla in un DateTime valore. Il secondo formato usa un modulo supportato dallo standard ISO 8601 per un oggetto che rappresenta 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);
let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
I TryParse metodi e TryParseExact indicano se una stringa è una rappresentazione valida di un DateTime valore e, in caso affermativo, 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 DateTime valori sono rappresentati come numero di tick (il numero di intervalli di 100 nanosecondi) trascorsi dalle 12:00:00 mezzanotte, 1 gennaio 0001. Il valore effettivo DateTime è indipendente dal modo in cui tale valore viene visualizzato quando viene visualizzato. L'aspetto di un DateTime valore è il risultato di un'operazione di formattazione che converte un valore nella relativa rappresentazione di stringa.
L'aspetto dei valori di data e ora dipende dalle impostazioni cultura, dagli standard internazionali, dai requisiti dell'applicazione e dalle preferenze personali. La DateTime struttura offre flessibilità nella formattazione dei valori di data e ora tramite overload di ToString. Il metodo predefinito DateTime.ToString() restituisce la rappresentazione di stringa di un valore di data e ora usando il modello di data e ora breve delle impostazioni cultura correnti. Nell'esempio seguente viene utilizzato il metodo predefinito DateTime.ToString() . Visualizza la data e l'ora usando il modello di data e ora breve 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{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 in impostazioni cultura specifiche per supportare scenari Web in cui il server può trovarsi in impostazioni cultura diverse dal client. Specificare le impostazioni cultura usando il DateTime.ToString(IFormatProvider) metodo per creare la rappresentazione di data breve e ora estesa in impostazioni cultura specifiche. Nell'esempio seguente viene utilizzato il DateTime.ToString(IFormatProvider) metodo per visualizzare la data e l'ora usando il modello di data breve e ora estesa per le impostazioni cultura 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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 DateTime.ToString(String) metodo restituisce la rappresentazione di stringa definita da un identificatore di formato standard o personalizzato usando le convenzioni di formattazione delle impostazioni cultura correnti. Nell'esempio seguente viene utilizzato il DateTime.ToString(String) metodo per visualizzare il modello di data e ora completo per le impostazioni cultura en-US, 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("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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 DateTime.ToString(String, IFormatProvider) metodo per visualizzare il modello di data e 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
let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{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
L'overload DateTime.ToString(String) può essere usato anche con una stringa di formato personalizzata per specificare altri formati. Nell'esempio seguente viene illustrato come formattare una stringa usando il formato standard ISO 8601 usato spesso 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, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00
let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00
Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00
Per altre informazioni sulla formattazione DateTime dei valori, vedere Stringhe di formato di data e ora standard e stringhe di formato di data e ora personalizzate.
Analizzare i valori DateTime dalle stringhe
L'analisi converte la rappresentazione di stringa di una data e 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 richiedono una varietà di forme e riflettono le convenzioni delle impostazioni cultura correnti o delle 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 "12/15/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 date come input nel formato di data breve delle impostazioni cultura correnti.
Utilizzare il Parse metodo o TryParse per convertire una stringa da uno dei formati di data e ora comuni utilizzati da impostazioni cultura a un DateTime valore. Nell'esempio seguente viene illustrato come usare TryParse per convertire le stringhe di data in formati specifici delle impostazioni cultura diversi in un DateTime valore. Modifica le impostazioni cultura correnti in Inglese (Regno Unito) e chiama il GetDateTimeFormats() metodo per generare una matrice di stringhe di data e ora. Passa quindi ogni elemento nella 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.
System.Threading.Thread.CurrentThread.CurrentCulture <-
System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"
let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()
printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
match DateTime.TryParse dateString with
| true, parsedDate ->
printfn $"%-37s{dateString} %-19O{parsedDate}\n"
| _ ->
badFormats.Add dateString
// Display strings that could not be parsed.
if badFormats.Count > 0 then
printfn "\nStrings that could not be parsed: "
for badFormat in badFormats do
printfn $" {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
Utilizzare i ParseExact metodi e TryParseExact per convertire una stringa che deve corrispondere a un formato o a un DateTime valore specifico. Specificare una o più stringhe di formato di data e ora come parametro per il metodo di analisi. Nell'esempio seguente viene usato il TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metodo per convertire le stringhe che devono trovarsi in un formato "aaaaMMMdd" o in un formato "HHmmss" in DateTime valori.
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
let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings =
[ "20130816"; "20131608"; " 20130816 "
"115216"; "521116"; " 115216 " ]
for dateString in dateStrings do
match DateTime.TryParseExact(dateString, formats, null,
System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
System.Globalization.DateTimeStyles.AdjustToUniversal) with
| true, parsedDate ->
printfn $"{dateString} --> {parsedDate:g}"
| _ ->
printfn $"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 per ParseExact è convertire una rappresentazione di stringa da un servizio Web, in genere in formato standard ISO 8601 . Il codice seguente mostra 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}");
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
printfn $"{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 e TryParseExact restituiscono un Boolean valore che indica se la conversione ha avuto esito positivo o negativo. È consigliabile usare i TryParse metodi o TryParseExact negli scenari in cui le prestazioni sono importanti. L'operazione di analisi per le stringhe di data e ora tende ad avere una frequenza di errore elevata e la gestione delle eccezioni è costosa. Utilizzare 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 DateTime tipo vengono spesso espresse usando lo standard UTC (Coordinated Universal Time). Coordinated Universal Time è il nome riconosciuto a livello internazionale per Greenwich Mean Time (GMT). Coordinated Universal Time è l'ora misurata a zero gradi di longitudine, ovvero il punto di origine UTC. L'ora legale non è applicabile alle ore UTC.
L'ora locale è relativa a un particolare fuso orario. Un fuso orario è associato a una differenza di 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 influenzata dall'ora legale, che aggiunge o sottrae una regolazione dell'intervallo di tempo. L'ora locale viene calcolata aggiungendo l'offset del fuso orario all'ora UTC e modificando l'ora legale, se necessario. La differenza di fuso orario in corrispondenza del punto di origine UTC è zero.
L'ora UTC è adatta per calcoli, confronti e archiviazione di date e ora nei file. L'ora locale è appropriata per la visualizzazione nelle interfacce utente delle applicazioni desktop. Anche le applicazioni che supportano il fuso orario (ad esempio molte applicazioni Web) devono lavorare con diversi altri fusi orari.
Se la Kind proprietà di un DateTime oggetto è DateTimeKind.Unspecified, non è specificato se l'ora rappresentata è l'ora locale, l'ora UTC o un'ora in un altro fuso orario.
Risoluzione DateTime
Nota
In alternativa all'esecuzione dell'aritmetica di data e ora sui DateTime valori per misurare il tempo trascorso, è possibile usare la Stopwatch classe .
La Ticks proprietà esprime valori di data e ora in unità di dieci milioni di secondi. La Millisecond proprietà restituisce i millesimi di un secondo in un valore di data e ora. L'uso DateTime.Now di chiamate ripetute alla proprietà per misurare il tempo trascorso dipende dall'orologio di sistema. L'orologio di sistema nei sistemi Windows 7 e Windows 8 ha una risoluzione di circa 15 millisecondi. Questa risoluzione influisce su intervalli di tempo inferiori a 100 millisecondi.
Nell'esempio seguente viene illustrata la dipendenza dei valori di data e ora correnti sulla risoluzione dell'orologio di sistema. Nell'esempio un ciclo esterno si ripete 20 volte e un ciclo interno serve a ritardare il ciclo esterno. Se il valore del contatore del ciclo esterno è 10, una chiamata al Thread.Sleep metodo introduce un ritardo di cinque millisecondi. Nell'esempio seguente viene illustrato il numero di millisecondi restituiti dalla DateTime.Now.Milliseconds proprietà 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.
let mutable output = ""
for i = 0 to 20 do
output <- output + $"{DateTime.Now.Millisecond}\n"
// Introduce a delay loop.
for _ = 0 to 1000 do ()
if i = 10 then
output <- output + "Thread.Sleep called...\n"
System.Threading.Thread.Sleep 5
printfn $"{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 usa una DateTime struttura, ad esempio Add o Subtract, non modifica il valore della 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 ora UTC e ora locale o tra un fuso orario e un altro) prendono in considerazione l'ora legale, ma le operazioni aritmetiche e di confronto non lo fanno.
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 ToLocalTime UTC nell'ora locale oppure usare il metodo per eseguire la conversione dall'ora locale all'ora ToUniversalTime UTC. Tuttavia, nella classe è disponibile TimeZoneInfo un set completo di metodi di conversione del fuso orario. Si converte l'ora in uno dei fusi orari del mondo nell'ora in qualsiasi altro fuso orario usando questi metodi.
I calcoli e i confronti degli DateTime oggetti sono significativi solo se gli oggetti rappresentano gli orari nello stesso fuso orario. È possibile usare un TimeZoneInfo oggetto per rappresentare il fuso orario di un DateTime valore, anche se i due sono ad accoppiamento libero. Un DateTime oggetto non dispone di una proprietà che restituisce un oggetto che rappresenta il fuso orario del valore di data e ora. La Kind proprietà indica se un DateTime oggetto rappresenta l'ora UTC, l'ora locale o non è specificato. In un'applicazione compatibile con il fuso orario, è necessario basarsi su un meccanismo esterno per determinare il fuso orario in cui è stato creato un DateTime oggetto. È possibile usare una struttura che esegue il wrapping sia del DateTime valore che dell'oggetto TimeZoneInfo che rappresenta il DateTime fuso orario del valore. Per informazioni dettagliate sull'uso dell'ora UTC nei calcoli e nei confronti con DateTime i valori, vedere Esecuzione di operazioni 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. Questi includono costruttori che specificano un calendario e metodi con un parametro derivato da IFormatProvider, ad esempio System.Globalization.DateTimeFormatInfo.
Le operazioni in base ai membri del DateTime tipo prendono in considerazione i dettagli, ad esempio gli anni bisestili e il numero di giorni in un mese.
Valori e calendari DateTime
La libreria di classi .NET include una serie di classi di calendario, tutte derivate dalla Calendar classe . Sono:
- 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 sui test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento dell'era, vedere Preparare l'applicazione per il cambiamento dell'era giapponese. Per le funzionalità di .NET che supportano calendari con più ere e per le procedure consigliate quando si usano calendari che supportano più ere, vedere Uso delle era.
Ogni impostazione cultura usa un calendario predefinito definito dalla relativa proprietà di sola lettura CultureInfo.Calendar . Ogni cultura può supportare uno o più calendari definiti dalla relativa proprietà di sola lettura CultureInfo.OptionalCalendars . Il calendario attualmente utilizzato da un oggetto specifico CultureInfo è definito dalla relativa DateTimeFormatInfo.Calendar proprietà. Deve essere uno dei calendari presenti nella CultureInfo.OptionalCalendars matrice.
Il calendario corrente delle impostazioni cultura viene usato in tutte le operazioni di formattazione per tali impostazioni cultura. Ad esempio, il calendario predefinito delle impostazioni cultura buddiste thai è il calendario buddista thai, rappresentato dalla ThaiBuddhistCalendar classe . Quando un CultureInfo oggetto che rappresenta le impostazioni cultura buddiste thai viene utilizzato in un'operazione di formattazione di data e ora, il calendario buddista thai viene utilizzato per impostazione predefinita. Il calendario gregoriano viene utilizzato solo se la proprietà delle DateTimeFormatInfo.Calendar impostazioni 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
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)
printfn $"{value.ToString thTH}"
thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{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 tali 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
let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"
thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{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
Si crea un'istanza di un DateTime 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 calendar parametro e passandolo un Calendar oggetto che rappresenta tale 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
let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"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 costruttori che non includono un calendar parametro presuppongono che gli elementi di data e ora siano espressi come unità nel calendario gregoriano.
Tutte le altre DateTime proprietà e metodi usano il calendario gregoriano. Ad esempio, la DateTime.Year proprietà restituisce l'anno nel calendario gregoriano e il DateTime.IsLeapYear(Int32) metodo presuppone che il year parametro sia un anno nel calendario gregoriano. Ogni DateTime membro che utilizza il calendario gregoriano ha un membro corrispondente della Calendar classe che utilizza un calendario specifico. Ad esempio, il Calendar.GetYear metodo restituisce l'anno in un calendario specifico e il Calendar.IsLeapYear metodo interpreta il year parametro come numero di anno in un calendario specifico. Nell'esempio seguente vengono utilizzati sia i DateTime membri che i membri corrispondenti della ThaiBuddhistCalendar classe .
var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
// Using the Thai Buddhist Era calendar
// Date : 28/5/2559
// Year: 2559
// Leap year : True
//
// Using the Gregorian calendar
// Date : 28/05/2016
// Year: 2016
// Leap year : True
let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"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 DayOfWeek proprietà che restituisce il giorno della settimana nel calendario 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 Calendar.GetWeekOfYear singolo calendario. Di seguito ne viene illustrato un esempio.
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
let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"
let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"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 sulle date e i calendari, vedere Utilizzo dei calendari.
Rendere persistenti i valori DateTime
È possibile rendere persistenti DateTime i valori nei modi seguenti:
- Convertirli in stringhe e rendere persistenti le stringhe.
- Convertirli in valori integer a 64 bit (il valore della Ticks proprietà) e rendere persistenti gli interi.
- Serializzare i valori DateTime.
È necessario assicurarsi che la routine che ripristina i DateTime valori non perda i dati o generi un'eccezione indipendentemente dalla tecnica scelta. DateTime i valori devono essere round trip. Ovvero, il valore originale e il valore ripristinato devono essere uguali. E se il valore originale DateTime rappresenta un singolo istante di tempo, deve identificare lo stesso momento di tempo in cui viene ripristinato.
Rendere persistenti i valori come stringhe
Per ripristinare DateTime correttamente i valori persistenti come stringhe, seguire queste regole:
Fare gli stessi presupposti sulla formattazione specifica delle impostazioni cultura quando si ripristina la stringa come quando è stata salvata in modo permanente. 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 è stato salvato, chiamare l'overload ToString per salvare la stringa usando le convenzioni delle impostazioni cultura invarianti. Chiamare l'overload Parse(String, IFormatProvider, DateTimeStyles) o TryParse(String, IFormatProvider, DateTimeStyles, DateTime) per ripristinare la stringa usando le convenzioni delle impostazioni cultura invarianti. Non usare mai gli ToString()overload , Parse(String)o TryParse(String, DateTime) , che usano le convenzioni delle impostazioni cultura correnti.
Se la data rappresenta un singolo momento dell'ora, assicurarsi che rappresenti lo stesso momento in cui viene ripristinato, anche in un fuso orario diverso. Convertire il DateTime valore in Utc (Coordinated Universal Time) prima di salvarlo o usare DateTimeOffset.
L'errore più comune generato durante la persistenza dei DateTime valori come stringhe consiste nell'basarsi sulle convenzioni di formattazione delle impostazioni cultura predefinite 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 è inglese (Stati Uniti). Ripristina le date utilizzando le convenzioni di formattazione di impostazioni cultura diverse, che in questo caso è inglese (Regno Unito). Poiché le convenzioni di formattazione delle due impostazioni cultura sono diverse, due delle date non possono essere ripristinate e le rimanenti tre date vengono interpretate in modo non corretto. Inoltre, se i valori di data e ora originali rappresentano singoli momenti nel tempo, le ore ripristinate non sono corrette perché le informazioni sul fuso orario vengono perse.
public static void PersistAsLocalStrings()
{
SaveLocalDatesAsString();
RestoreLocalDatesFromString();
}
private static void SaveLocalDatesAsString()
{
DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
new DateTime(2014, 7, 10, 23, 49, 0),
new DateTime(2015, 1, 10, 1, 16, 0),
new DateTime(2014, 12, 20, 21, 45, 0),
new DateTime(2014, 6, 2, 15, 14, 0) };
string? output = null;
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
for (int ctr = 0; ctr < dates.Length; ctr++)
{
Console.WriteLine(dates[ctr].ToString("f"));
output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
}
var sw = new StreamWriter(filenameTxt);
sw.Write(output);
sw.Close();
Console.WriteLine("Saved dates...");
}
private static void RestoreLocalDatesFromString()
{
TimeZoneInfo.ClearCachedData();
Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
StreamReader sr = new StreamReader(filenameTxt);
string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
StringSplitOptions.RemoveEmptyEntries);
sr.Close();
Console.WriteLine("The dates on an {0} system:",
Thread.CurrentThread.CurrentCulture.Name);
foreach (var inputValue in inputValues)
{
DateTime dateValue;
if (DateTime.TryParse(inputValue, out dateValue))
{
Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
}
else
{
Console.WriteLine($"Cannot parse '{inputValue}'");
}
}
Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
// Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
// The dates on an en-US system:
// Saturday, June 14, 2014 6:32 AM
// Thursday, July 10, 2014 11:49 PM
// Saturday, January 10, 2015 1:16 AM
// Saturday, December 20, 2014 9:45 PM
// Monday, June 02, 2014 3:14 PM
// Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
// Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
// The dates on an en-GB system:
// Cannot parse //6/14/2014 6:32:00 AM//
// //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
// //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
// Cannot parse //12/20/2014 9:45:00 PM//
// //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
// Restored dates...
let saveLocalDatesAsString () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let output =
[ for date in dates do
printfn $"{date}"
string date ]
|> String.concat "|"
use sw = new StreamWriter(filenameTxt)
sw.Write output
printfn "Saved dates..."
let restoreLocalDatesFromString () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use sr = new StreamReader(filenameTxt)
let inputValues =
sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for inputValue in inputValues do
match DateTime.TryParse inputValue with
| true, dateValue ->
printfn $"'{inputValue}' --> {dateValue:f}"
| _ ->
printfn $"Cannot parse '{inputValue}'"
printfn "Restored dates..."
let persistAsLocalStrings () =
saveLocalDatesAsString ()
restoreLocalDatesFromString ()
// 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 , seguire questa procedura:
- Se i valori rappresentano singoli momenti di tempo, convertirli dall'ora locale all'ora UTC chiamando il ToUniversalTime metodo .
- Convertire le date nelle relative rappresentazioni di stringa chiamando l'overload ToString(String, IFormatProvider) o String.Format(IFormatProvider, String, Object[]) . 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 persistenti DateTime senza perdita di dati, seguire questa procedura:
- Analizzare i dati chiamando l'overload ParseExact o TryParseExact . Specificare CultureInfo.InvariantCulture come
providerargomento e usare la stessa stringa di formato standard usata per l'argomento durante laformatconversione. Includere il DateTimeStyles.RoundtripKind valore nell'argomentostyles. - Se i DateTime valori rappresentano singoli momenti nel tempo, chiamare il ToLocalTime metodo per convertire la data 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 DateTime 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 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...
let saveDatesAsInvariantStrings () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let output =
[ for date in dates do
printfn $"{date:f}"
date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
|> String.concat "|"
use sw = new StreamWriter(filenameTxt)
sw.Write output
printfn "Saved dates..."
let restoreDatesAsInvariantStrings () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use sr = new StreamReader(filenameTxt)
let inputValues =
sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for inputValue in inputValues do
match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
| true, dateValue ->
printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
| _ ->
printfn $"Cannot parse '{inputValue}'"
printfn "Restored dates..."
let persistAsInvariantStrings () =
saveDatesAsInvariantStrings ()
restoreDatesAsInvariantStrings ()
// 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...
Rendere persistenti i valori come numeri interi
È possibile rendere persistente una data e un'ora Int64 come valore che rappresenta un numero di tick. In questo caso, non è necessario considerare le impostazioni cultura dei sistemi in cui i DateTime valori vengono mantenuti e ripristinati.
Per rendere persistente un DateTime valore come numero intero:
- Se i DateTime valori rappresentano singoli momenti nel tempo, convertirli in formato UTC chiamando il ToUniversalTime metodo .
- Recuperare il numero di tick rappresentati dal DateTime valore dalla relativa Ticks proprietà.
Per ripristinare un DateTime valore persistente come integer:
- Creare un'istanza di un nuovo DateTime oggetto passando il Int64 valore al DateTime(Int64) costruttore.
- Se il DateTime valore rappresenta un singolo momento in tempo, convertirlo dall'ora UTC all'ora locale chiamando il ToLocalTime metodo .
Nell'esempio seguente viene mantenuta una matrice di DateTime valori come numeri interi in un sistema nel fuso orario pacifico degli Stati Uniti. Viene ripristinato in un sistema nell'area UTC. Il file che contiene i numeri interi include un Int32 valore che indica il numero totale di Int64 valori 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...
let saveDatesAsInts () =
let dates =
[ DateTime(2014, 6, 14, 6, 32, 0)
DateTime(2014, 7, 10, 23, 49, 0)
DateTime(2015, 1, 10, 1, 16, 0)
DateTime(2014, 12, 20, 21, 45, 0)
DateTime(2014, 6, 2, 15, 14, 0) ]
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let ticks =
[| for date in dates do
printfn $"{date:f}"
date.ToUniversalTime().Ticks |]
use fs = new FileStream(filenameInts, FileMode.Create)
use bw = new BinaryWriter(fs)
bw.Write ticks.Length
for tick in ticks do
bw.Write tick
printfn "Saved dates..."
let restoreDatesAsInts () =
TimeZoneInfo.ClearCachedData()
printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
use fs = new FileStream(filenameInts, FileMode.Open)
use br = new BinaryReader(fs)
try
let items = br.ReadInt32()
let dates =
[| for _ in 0..items do
let ticks = br.ReadInt64()
DateTime(ticks).ToLocalTime() |]
printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
for value in dates do
printfn $"{value:f}"
with
| :? EndOfStreamException ->
printfn "File corruption detected. Unable to restore data..."
| :? IOException ->
printfn "Unspecified I/O error. Unable to restore data..."
// Thrown during array initialization.
| :? OutOfMemoryException ->
printfn"File corruption detected. Unable to restore data..."
printfn "Restored dates..."
let persistAsIntegers () =
saveDatesAsInts ()
restoreDatesAsInts ()
// 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...
Serializzare i valori DateTime
È possibile rendere persistenti DateTime i valori tramite la serializzazione in un flusso o in un file e quindi ripristinarli tramite la deserializzazione. DateTime i dati vengono serializzati in un formato di oggetto specificato. Gli oggetti vengono ripristinati quando vengono deserializzati. Un formattatore o un serializzatore, ad esempio JsonSerializer o XmlSerializer, gestisce il processo di serializzazione e deserializzazione. Per altre informazioni sulla serializzazione e sui tipi di serializzazione supportati da .NET, vedere Serializzazione.
Nell'esempio seguente viene utilizzata la XmlSerializer classe per serializzare e deserializzare DateTime i valori. I valori rappresentano tutti i giorni dell'anno bisestile nel ventunesimo secolo. L'output rappresenta il risultato se l'esempio viene eseguito in un sistema le cui impostazioni cultura correnti sono inglese (Regno Unito). Poiché l'oggetto DateTime stesso è stato deserializzato, il codice non deve gestire le differenze culturali nei formati di data e ora.
public static void PersistAsXML()
{
// Serialize the data.
var leapYears = new List<DateTime>();
for (int year = 2000; year <= 2100; year += 4)
{
if (DateTime.IsLeapYear(year))
leapYears.Add(new DateTime(year, 2, 29));
}
DateTime[] dateArray = leapYears.ToArray();
var serializer = new XmlSerializer(dateArray.GetType());
TextWriter sw = new StreamWriter(filenameXml);
try
{
serializer.Serialize(sw, dateArray);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.InnerException?.Message);
}
finally
{
if (sw != null) sw.Close();
}
// Deserialize the data.
DateTime[]? deserializedDates;
using (var fs = new FileStream(filenameXml, FileMode.Open))
{
deserializedDates = (DateTime[]?)serializer.Deserialize(fs);
}
// Display the dates.
Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
int nItems = 0;
if (deserializedDates is not null)
{
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
let persistAsXML () =
// Serialize the data.
let leapYears =
[| for year in 2000..4..2100 do
if DateTime.IsLeapYear year then
DateTime(year, 2, 29) |]
let serializer = XmlSerializer(leapYears.GetType())
use sw = new StreamWriter(filenameXml)
try
serializer.Serialize(sw, leapYears)
with :? InvalidOperationException as e ->
printfn $"{e.InnerException.Message}"
// Deserialize the data.
use fs = new FileStream(filenameXml, FileMode.Open)
let deserializedDates = serializer.Deserialize fs :?> DateTime []
// Display the dates.
printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
let mutable nItems = 0
for dat in deserializedDates do
printf $" {dat:d} "
nItems <- nItems + 1
if nItems % 5 = 0 then
printfn ""
// 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 DateTime valore rappresenta un momento nel tempo ed è espresso come ora locale, convertirlo dall'ora locale all'ora UTC prima di serializzarlo chiamando il ToUniversalTime metodo . Dopo averlo deserializzato, convertirlo dall'ora UTC all'ora locale chiamando il ToLocalTime metodo .
DateTime e TimeSpan
I DateTime tipi di valore e TimeSpan differiscono in quanto rappresenta DateTime un istante nel tempo, mentre un TimeSpan oggetto rappresenta un intervallo di tempo. È possibile sottrarre un'istanza di DateTime da un'altra per ottenere un TimeSpan oggetto che rappresenta l'intervallo di tempo tra di essi. In alternativa, è possibile aggiungere un positivo TimeSpan all'oggetto corrente DateTime per ottenere un DateTime valore che rappresenta una data 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.
Confrontare l'uguaglianza all'interno della tolleranza
I confronti di uguaglianza per DateTime i valori sono esatti. Per essere considerati uguali, due valori devono essere espressi come lo stesso numero di tick. Questa precisione è spesso non necessaria o anche errata per molte applicazioni. Spesso, si vuole verificare se DateTime gli oggetti sono approssimativamente uguali.
Nell'esempio seguente viene illustrato come confrontare valori approssimativamente equivalenti DateTime . 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
let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
let delta =
int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
abs delta < windowInSeconds
let testRoughlyEquals () =
let window = 10
let window' = 10.
let freq = 60 * 60 * 2 // 2 hours
let d1 = DateTime.Now
let d2 = d1.AddSeconds(2. * window')
let d3 = d1.AddSeconds(-2. * window')
let d4 = d1.AddSeconds(window' / 2.)
let d5 = d1.AddSeconds(-window' / 2.)
let d6 = (d1.AddHours 2).AddSeconds(2. * window')
let d7 = (d1.AddHours 2).AddSeconds(-2. * window')
let d8 = (d1.AddHours 2).AddSeconds(window' / 2.)
let d9 = (d1.AddHours 2).AddSeconds(-window' / 2.)
printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"
printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
printfn $"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 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 si potrebbe prevedere.
Se si esegue il round trip solo un'ora, ad esempio le 3:00, la data e l'ora finali sono il 30 dicembre 1899 E. alle 13:00, anziché il 1° gennaio 0001 E. alle 13:00 . NET 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 .NET presuppone una data di base del 1° gennaio 0001 C.E.
Quando viene passato solo un tempo da .NET a COM, viene eseguita un'elaborazione speciale che converte il tempo nel formato utilizzato da COM. Quando viene passata solo un'ora da COM a .NET, non viene eseguita alcuna elaborazione speciale perché potrebbe danneggiare date e ore legittime il 30 dicembre 1899. Se una data inizia il round trip da COM, .NET e COM mantengono la data.
Il comportamento di .NET e COM significa che se l'applicazione esegue il round trip di un DateTime oggetto che specifica solo un'ora, l'applicazione deve ricordare di modificare o ignorare la data errata dall'oggetto finale DateTime .
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per