Condividi tramite

Analizzare le stringhe di data e ora in .NET

.NET offre diversi tipi per l'uso dei dati di data e ora, ognuno ottimizzato per scenari diversi:

  • DateTime - Rappresenta una data e un'ora insieme, ideale quando sono necessari entrambi i componenti o quando si lavora con il codice legacy.
  • DateOnly (non disponibile in .NET Framework): rappresenta solo una data senza informazioni sull'ora, perfetta per compleanni, anniversari o date aziendali.
  • TimeOnly (non disponibile in .NET Framework): rappresenta solo un'ora senza informazioni sulla data, ideale per pianificazioni, allarmi o eventi giornalieri ricorrenti.

Ogni tipo fornisce metodi di analisi che convertono le stringhe nei rispettivi oggetti, con diversi livelli di flessibilità e controllo sul processo di analisi.

Concetti comuni di analisi

Tutti e tre i tipi di data e ora condividono approcci di analisi simili:

  • Parse e TryParse metodi - Consente di convertire molte rappresentazioni di stringa comuni usando le impostazioni culturali correnti o quelle specificate.
  • ParseExact e TryParseExact metodi - Converte stringhe che rispettano modelli di formato specifici, fornendo un controllo preciso sui formati attesi, comprese le impostazioni culturali.
  • Stringhe di formato : consente di definire modelli per l'analisi usando identificatori di formato standard o personalizzati.

Culture diverse usano ordini diversi per giorno, mese e anno. Alcune rappresentazioni temporali usano un orologio di 24 ore, altre specificano "AM" e "PM". I metodi di parsing gestiscono queste varianti tramite regole di formattazione specifiche della cultura.

L'oggetto DateTimeFormatInfo fornisce il controllo sulla modalità di interpretazione del testo. Le proprietà descrivono i separatori di data e ora, i nomi di mesi, giorni, ere e il formato per le designazioni "AM" e "PM". È possibile specificare le impostazioni della cultura tramite il parametro IFormatProvider utilizzando un oggetto CultureInfo o un oggetto DateTimeFormatInfo.

Per altre informazioni sui modelli di formato, vedere stringhe di formato di data e ora standard e stringhe di formato di data e ora personalizzate.

Importante

DateOnly e TimeOnly tipi non sono disponibili per .NET Framework.

Analisi DateTime

DateTime rappresenta i componenti di data e ora insieme. Quando si analizzano le stringhe agli DateTime oggetti, è necessario considerare diversi DateTimeaspetti specifici:

  • Gestione delle informazioni mancanti - DateTime usa le impostazioni predefinite quando le parti non sono presenti nella stringa di input.
  • Supporto - per DateTime può rappresentare fusi orari locali, UTC o non specificati.
  • Analisi di data e ora combinata : deve gestire i componenti di data e ora in un'unica operazione.

Gestione delle informazioni mancanti

Il testo che rappresenta una data o un'ora potrebbe non avere alcune informazioni. Ad esempio, la maggior parte delle persone presuppone che la data "Marzo 12" rappresenti l'anno corrente. Analogamente, "Marzo 2018" rappresenta il mese di marzo nell'anno 2018. Il testo che rappresenta l'ora include spesso solo ore, minuti e una designazione AM/PM. DateTime I metodi di analisi gestiscono queste informazioni mancanti usando valori predefiniti ragionevoli:

  • Quando è presente solo l'ora, la parte relativa alla data usa la data corrente.
  • Quando è presente solo la data, la parte dell'ora è mezzanotte.
  • Quando l'anno non viene specificato in una data, viene utilizzato l'anno corrente.
  • Quando il giorno del mese non viene specificato, viene usato il primo giorno del mese.

Se la data è presente nella stringa, deve includere il mese e uno del giorno o dell'anno. Se l'ora è presente, deve includere l'ora e i minuti o l'indicatore AM/PM.

È possibile specificare la costante per eseguire l'override NoCurrentDateDefault di queste impostazioni predefinite. Quando si usa tale costante, le proprietà di anno, mese o giorno mancanti vengono impostate sul valore 1. L'ultimo esempio che usa Parse illustra questo comportamento.

Offset UTC e gestione del fuso orario

Oltre a un componente di data e ora, la rappresentazione di stringa di una data e ora può includere un offset che indica quanto l'ora differisce rispetto all'ora UTC (Coordinated Universal Time). Ad esempio, la stringa "2/14/2007 5:32:00 -7:00" definisce un'ora di sette ore prima dell'ora UTC. Se un offset viene omesso dalla rappresentazione di stringa di un'ora, l'analisi restituisce un DateTime oggetto con la relativa Kind proprietà impostata su DateTimeKind.Unspecified. Se viene specificato un offset, l'analisi restituisce un DateTime oggetto con la relativa Kind proprietà impostata su DateTimeKind.Local. Il valore viene modificato anche nel fuso orario locale del computer. È possibile modificare questo comportamento usando un DateTimeStyles valore con il metodo di analisi.

Gestione delle date ambigue

Il provider di formato viene usato anche per interpretare una data numerica ambigua. Non è chiaro quali componenti della data rappresentata dalla stringa "02/03/04" sono il mese, il giorno e l'anno. I componenti vengono interpretati in base all'ordine dei formati di data simili nel provider di formato.

DateTime.Parse

Nell'esempio seguente viene illustrato l'uso del DateTime.Parse metodo per convertire un oggetto string in un oggetto DateTime. In questo esempio viene utilizzata la cultura associata al thread corrente. Se l'oggetto CultureInfo associato alla cultura corrente non è in grado di analizzare la stringa di input, viene generata un'eccezione FormatException.

static void DateTimeParseExample()
{
    // Parse common date and time formats using current culture
    var dateTime1 = DateTime.Parse("1/15/2025 3:30 PM");
    var dateTime2 = DateTime.Parse("January 15, 2025");
    var dateTime3 = DateTime.Parse("15:30:45");

    Console.WriteLine($"Parsed: {dateTime1}");
    Console.WriteLine($"Parsed: {dateTime2}");
    Console.WriteLine($"Parsed: {dateTime3}");

    // Parse with specific culture
    var germanDate = DateTime.Parse("15.01.2025", new CultureInfo("de-DE"));
    Console.WriteLine($"German date parsed: {germanDate}");
}

Sub DateTimeParseExample()
    ' Parse common date and time formats using current culture
    Dim dateTime1 = DateTime.Parse("1/15/2025 3:30 PM")
    Dim dateTime2 = DateTime.Parse("January 15, 2025")
    Dim dateTime3 = DateTime.Parse("15:30:45")

    Console.WriteLine($"Parsed: {dateTime1}")
    Console.WriteLine($"Parsed: {dateTime2}")
    Console.WriteLine($"Parsed: {dateTime3}")

    ' Parse with specific culture
    Dim germanDate = DateTime.Parse("15.01.2025", New CultureInfo("de-DE"))
    Console.WriteLine($"German date parsed: {germanDate}")
End Sub

È anche possibile definire in modo esplicito la cultura le cui convenzioni di formattazione vengono utilizzate durante l'esame di una stringa. Specificare uno degli oggetti standard DateTimeFormatInfo restituiti dalla CultureInfo.DateTimeFormat proprietà . Nell'esempio seguente viene usato un provider di formato per analizzare una stringa tedesca in un oggetto DateTime. Crea un oggetto CultureInfo che rappresenta la cultura de-DE. L'oggetto CultureInfo garantisce un'analisi corretta di questa particolare stringa. Questo processo esclude qualsiasi impostazione nel CurrentCulture di CurrentThread.

static void DateTimeParseGermanExample()
{
    var cultureInfo = new CultureInfo("de-DE");
    string dateString = "12 Juni 2008";
    var dateTime = DateTime.Parse(dateString, cultureInfo);
    Console.WriteLine(dateTime);
    // The example displays the following output:
    //       6/12/2008 00:00:00
}

Sub DateTimeParseGermanExample()
    Dim MyCultureInfo As New CultureInfo("de-DE")
    Dim MyString As String = "12 Juni 2008"
    Dim MyDateTime As DateTime = DateTime.Parse(MyString, MyCultureInfo)
    Console.WriteLine(MyDateTime)
    ' The example displays the following output:
    '       6/12/2008 00:00:00
End Sub

Tuttavia, è possibile usare i sovraccarichi del metodo Parse per specificare fornitori di formati personalizzati. Il Parse metodo non supporta l'analisi di formati non standard. Per analizzare una data e un'ora espressa in un formato non standard, usare invece il ParseExact metodo .

Nell'esempio seguente viene utilizzata l'enumerazione DateTimeStyles per specificare che le informazioni di data e ora correnti non devono essere aggiunte a DateTime per i campi non specificati.

static void DateTimeParseNoDefaultExample()
{
    var cultureInfo = new CultureInfo("de-DE");
    string dateString = "12 Juni 2008";
    var dateTime = DateTime.Parse(dateString, cultureInfo,
                                    DateTimeStyles.NoCurrentDateDefault);
    Console.WriteLine(dateTime);
    // The example displays the following output if the current culture is en-US:
    //      6/12/2008 00:00:00
}

Sub DateTimeParseNoDefaultExample()
    Dim MyCultureInfo As New CultureInfo("de-DE")
    Dim MyString As String = "12 Juni 2008"
    Dim MyDateTime As DateTime = DateTime.Parse(MyString, MyCultureInfo,
                               DateTimeStyles.NoCurrentDateDefault)
    Console.WriteLine(MyDateTime)
    ' The example displays the following output if the current culture is en-US:
    '       6/12/2008 00:00:00
End Sub

DateTime.ParseExact

Il DateTime.ParseExact metodo converte una stringa in un DateTime oggetto se è conforme a uno dei modelli di stringa specificati. Quando una stringa che non è una delle forme specificate viene passata a questo metodo, viene generata un'eccezione FormatException . È possibile specificare uno degli identificatori di formato di data e ora standard o una combinazione degli identificatori di formato personalizzati. Usando gli identificatori di formato personalizzati, è possibile creare una stringa di riconoscimento personalizzata. Per una spiegazione degli identificatori, vedere gli articoli sulle stringhe di formato di data e ora standard e stringhe di formato di data e ora personalizzate.

Nell'esempio seguente, al metodo DateTime.ParseExact viene passato un oggetto stringa da analizzare, seguito da un identificatore di formato, seguito da un oggetto CultureInfo. Questo ParseExact metodo può interpretare solo le stringhe che seguono il formato di data lungo nella en-US cultura.

static void DateTimeParseExactExample()
{
    // Parse exact format
    var exactDate = DateTime.ParseExact("2025-01-15T14:30:00", "yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture);
    Console.WriteLine($"Exact parse: {exactDate}");

    // Parse with custom format
    var customDate = DateTime.ParseExact("15/Jan/2025 2:30 PM", "dd/MMM/yyyy h:mm tt", CultureInfo.InvariantCulture);
    Console.WriteLine($"Custom format: {customDate}");
}

Sub DateTimeParseExactExample()
    ' Parse exact format
    Dim exactDate = DateTime.ParseExact("2025-01-15T14:30:00", "yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture)
    Console.WriteLine($"Exact parse: {exactDate}")

    ' Parse with custom format
    Dim customDate = DateTime.ParseExact("15/Jan/2025 2:30 PM", "dd/MMM/yyyy h:mm tt", CultureInfo.InvariantCulture)
    Console.WriteLine($"Custom format: {customDate}")
End Sub

Ogni overload dei metodi Parse e ParseExact include anche un parametro IFormatProvider che fornisce informazioni specifiche alle impostazioni cultura-specifiche sulla formattazione della stringa. L'oggetto IFormatProvider è un CultureInfo oggetto che rappresenta una cultura standard o un DateTimeFormatInfo oggetto restituito dalla CultureInfo.DateTimeFormat proprietà. ParseExact usa inoltre un argomento stringa o matrice di stringhe aggiuntivo che definisce uno o più formati di data e ora personalizzati.

Analisi dateOnly

La DateOnly struttura rappresenta solo una data senza informazioni sull'ora, rendendola perfetta per scenari come compleanni, anniversari o date aziendali. Poiché non dispone di alcun componente ora, rappresenta una data dall'inizio del giorno alla fine del giorno.

DateOnly offre diversi vantaggi rispetto all'uso DateTime per scenari di sola data:

  • La struttura DateTime potrebbe spostarsi al giorno precedente o successivo se viene modificata da un fuso orario. DateOnly non può essere offset in base a un fuso orario e rappresenta sempre la data impostata.
  • Serializzare DateOnly include meno dati rispetto a DateTime.
  • Quando il codice interagisce con un database, ad esempio SQL Server, le date intere vengono in genere archiviate come il tipo di dati date, che non include un'ora. DateOnly corrisponde meglio al tipo di database.

DateOnly.Parse

Il DateOnly.Parse metodo converte le rappresentazioni di stringa di data comuni in un DateOnly oggetto . Il metodo accetta diversi formati e usa la cultura corrente o specificata per il parsing.

static void DateOnlyParseExample()
{
    // Parse common date formats
    var date1 = DateOnly.Parse("1/15/2025");
    var date2 = DateOnly.Parse("January 15, 2025", CultureInfo.InvariantCulture);
    var date3 = DateOnly.Parse("2025-01-15");

    Console.WriteLine($"Parsed date: {date1}");
    Console.WriteLine($"Parsed date: {date2.ToString("D")}"); // Long date format
    Console.WriteLine($"Parsed date: {date3.ToString("yyyy-MM-dd")}");

    // Parse with specific culture
    var germanDate = DateOnly.Parse("15.01.2025", new CultureInfo("de-DE"));
    Console.WriteLine($"German date: {germanDate}");
}

Sub DateOnlyParseExample()
    ' Parse common date formats
    Dim date1 = DateOnly.Parse("1/15/2025")
    Dim date2 = DateOnly.Parse("January 15, 2025", CultureInfo.InvariantCulture)
    Dim date3 = DateOnly.Parse("2025-01-15")

    Console.WriteLine($"Parsed date: {date1}")
    Console.WriteLine($"Parsed date: {date2.ToString("D")}") ' Long date format
    Console.WriteLine($"Parsed date: {date3.ToString("yyyy-MM-dd")}")

    ' Parse with specific culture
    Dim germanDate = DateOnly.Parse("15.01.2025", New CultureInfo("de-DE"))
    Console.WriteLine($"German date: {germanDate}")
End Sub

DateOnly.ParseExact

Il DateOnly.ParseExact metodo fornisce un controllo preciso sul formato previsto della stringa di input. Usare questo metodo quando si conosce il formato esatto della stringa di data e si vuole garantire un'analisi rigorosa.

static void DateOnlyParseExactExample()
{
    // Parse exact format
    var exactDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture);
    Console.WriteLine($"Exact date: {exactDate}");

    // Parse ISO format
    var isoDate = DateOnly.ParseExact("2025-01-15", "yyyy-MM-dd", CultureInfo.InvariantCulture);
    Console.WriteLine($"ISO date: {isoDate}");

    // Parse with multiple possible formats
    string[] formats = { "MM/dd/yyyy", "M/d/yyyy", "dd/MM/yyyy" };
    var flexibleDate = DateOnly.ParseExact("1/15/2025", formats, CultureInfo.InvariantCulture, DateTimeStyles.None);
    Console.WriteLine($"Flexible parse: {flexibleDate}");
}

Sub DateOnlyParseExactExample()
    ' Parse exact format
    Dim exactDate = DateOnly.ParseExact("21 Oct 2015", "dd MMM yyyy", CultureInfo.InvariantCulture)
    Console.WriteLine($"Exact date: {exactDate}")

    ' Parse ISO format
    Dim isoDate = DateOnly.ParseExact("2025-01-15", "yyyy-MM-dd", CultureInfo.InvariantCulture)
    Console.WriteLine($"ISO date: {isoDate}")

    ' Parse with multiple possible formats
    Dim formats() As String = {"MM/dd/yyyy", "M/d/yyyy", "dd/MM/yyyy"}
    Dim flexibleDate = DateOnly.ParseExact("1/15/2025", formats, CultureInfo.InvariantCulture, DateTimeStyles.None)
    Console.WriteLine($"Flexible parse: {flexibleDate}")
End Sub

Il ParseExact metodo accetta una singola stringa di formato o una matrice di stringhe di formato, consentendo di analizzare le date che potrebbero venire in più formati accettabili.

Analisi del TimeOnly

La TimeOnly struttura rappresenta un valore di ora del giorno, ad esempio un orario di sveglia giornaliero o l'ora in cui si mangia il pranzo ogni giorno. TimeOnly è limitato all'intervallo di 00:00:00.00000000 - 23:59:59.999999999, un'ora specifica del giorno.

TimeOnly risolve diversi problemi che esistevano quando si usano altri tipi per scenari di sola durata:

  • TimeSpan rappresenta il tempo trascorso e può essere negativo o superiore a 24 ore, rendendolo non adatto per rappresentare un'ora specifica del giorno.
  • L'uso DateTime di per un'ora del giorno richiede una data arbitraria, che può causare un comportamento imprevisto durante l'esecuzione di calcoli.
  • TimeOnly gestisce automaticamente il rollover di 24 ore quando si sommano o sottraggono valori temporali.

TimeOnly.Parse

Il TimeOnly.Parse metodo converte le rappresentazioni di stringhe temporali comuni in un TimeOnly oggetto . Il metodo accetta diversi formati, tra cui notazione di 12 ore e 24 ore.

static void TimeOnlyParseExample()
{
    // Parse common time formats
    var time1 = TimeOnly.Parse("14:30:15");
    var time2 = TimeOnly.Parse("2:30 PM", CultureInfo.InvariantCulture);
    var time3 = TimeOnly.Parse("17:45");

    Console.WriteLine($"Parsed time: {time1}");
    Console.WriteLine($"Parsed time: {time2.ToString("t")}"); // Short time format
    Console.WriteLine($"Parsed time: {time3.ToString("HH:mm")}");

    // Parse with milliseconds
    var preciseTime = TimeOnly.Parse("14:30:15.123");
    Console.WriteLine($"Precise time: {preciseTime.ToString("HH:mm:ss.fff")}");
}

Sub TimeOnlyParseExample()
    ' Parse common time formats
    Dim time1 = TimeOnly.Parse("14:30:15")
    Dim time2 = TimeOnly.Parse("2:30 PM", CultureInfo.InvariantCulture)
    Dim time3 = TimeOnly.Parse("17:45")

    Console.WriteLine($"Parsed time: {time1}")
    Console.WriteLine($"Parsed time: {time2.ToString("t")}") ' Short time format
    Console.WriteLine($"Parsed time: {time3.ToString("HH:mm")}")

    ' Parse with milliseconds
    Dim preciseTime = TimeOnly.Parse("14:30:15.123")
    Console.WriteLine($"Precise time: {preciseTime.ToString("HH:mm:ss.fff")}")
End Sub

TimeOnly.ParseExact

Il TimeOnly.ParseExact metodo fornisce un controllo preciso sul formato previsto della stringa di tempo di input. Usare questo metodo quando si conosce il formato esatto e si vuole garantire un'analisi rigorosa.

static void TimeOnlyParseExactExample()
{
    // Parse exact format
    var exactTime = TimeOnly.ParseExact("5:00 pm", "h:mm tt", CultureInfo.InvariantCulture);
    Console.WriteLine($"Exact time: {exactTime}");

    // Parse 24-hour format
    var militaryTime = TimeOnly.ParseExact("17:30:25", "HH:mm:ss", CultureInfo.InvariantCulture);
    Console.WriteLine($"Military time: {militaryTime}");

    // Parse with multiple possible formats
    string[] timeFormats = { "h:mm tt", "HH:mm", "H:mm" };
    var flexibleTime = TimeOnly.ParseExact("2:30 PM", timeFormats, CultureInfo.InvariantCulture, DateTimeStyles.None);
    Console.WriteLine($"Flexible time parse: {flexibleTime}");
}

Sub TimeOnlyParseExactExample()
    ' Parse exact format
    Dim exactTime = TimeOnly.ParseExact("5:00 pm", "h:mm tt", CultureInfo.InvariantCulture)
    Console.WriteLine($"Exact time: {exactTime}")

    ' Parse 24-hour format
    Dim militaryTime = TimeOnly.ParseExact("17:30:25", "HH:mm:ss", CultureInfo.InvariantCulture)
    Console.WriteLine($"Military time: {militaryTime}")

    ' Parse with multiple possible formats
    Dim timeFormats() As String = {"h:mm tt", "HH:mm", "H:mm"}
    Dim flexibleTime = TimeOnly.ParseExact("2:30 PM", timeFormats, CultureInfo.InvariantCulture, DateTimeStyles.None)
    Console.WriteLine($"Flexible time parse: {flexibleTime}")
End Sub

Vedere anche

  • Last updated on