DateTime.Parse Metodo
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Converte la rappresentazione di stringa di una data e un'ora nel relativo DateTime equivalente.
Parse(String) |
Converte la rappresentazione di stringa di una data e un'ora nel relativo DateTime equivalente usando le convenzioni delle impostazioni cultura correnti. |
Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analizza un intervallo di caratteri in un valore. |
Parse(String, IFormatProvider) |
Converte la rappresentazione di stringa di una data e un'ora nel relativo DateTime equivalente usando informazioni sul formato specifiche delle impostazioni cultura. |
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) |
Converte un intervallo di memoria che contiene la rappresentazione di stringa di una data e dell'ora nel relativo DateTime equivalente utilizzando informazioni di formato specifiche delle impostazioni cultura e uno stile di formattazione. |
Parse(String, IFormatProvider, DateTimeStyles) |
Converte la rappresentazione di stringa di una data e un'ora nel relativo DateTime equivalente usando informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione. |
Numerosi esempi che chiamano il metodo
Nota
Alcuni esempi di C# in questo articolo vengono eseguiti nello strumento di esecuzione e nel playground del codice inline Try.NET. Selezionare 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, nella finestra interattiva vengono visualizzati tutti i messaggi di errore del compilatore C#.
Il fuso orario locale dello strumento di esecuzione del codice inline Try.NET e playground è Coordinated Universal Time o UTC. Ciò potrebbe influire sul comportamento e sull'output degli esempi che illustrano i tipi DateTime, DateTimeOffsete TimeZoneInfo e i relativi membri.
È anche possibile scaricare un set completo di esempi di DateTime.Parse
, inclusi in un progetto .NET Core per C#.
In questa sezione:
- quale metodo chiamare?
- Stringa da analizzare
- convenzioni di analisi e cultura di
- l'analisi e gli elementi di stile
- Il valore restituito e dateTime.Kind
A | Chiamare |
---|---|
Analizzare una stringa di data e ora usando le convenzioni delle impostazioni cultura correnti. | overload Parse(String) |
Analizzare una stringa di data e ora usando le convenzioni di impostazioni cultura specifiche. | overload Parse(String, IFormatProvider) (vedere Analisi e convenzioni culturali) |
Analizzare una stringa di data e ora con elementi di stile speciali, ad esempio spazi vuoti o senza spazi vuoti. | overload Parse(String, IFormatProvider, DateTimeStyles) |
Analizzare una stringa di data e ora che deve essere in un formato specifico. | DateTime.ParseExact o DateTime.TryParseExact |
Analizzare una stringa di data e ora ed eseguire una conversione in ora UTC o locale. | overload Parse(String, IFormatProvider, DateTimeStyles) |
Analizzare una stringa di data e ora senza gestire le eccezioni. | metodo DateTime.TryParse |
Ripristinare (round trip) un valore di data e ora creato da un'operazione di formattazione. | Passare la stringa di formato standard "o" o "r" al metodo ToString(String) e chiamare l'overload Parse(String, IFormatProvider, DateTimeStyles) con DateTimeStyles.RoundtripKind |
Analizzare una stringa di data e ora in un formato fisso tra i limiti del computer (ed eventualmente culturale). | metodo DateTime.ParseExact o DateTime.TryParseExact |
Il metodo Parse tenta di convertire la rappresentazione di stringa di un valore di data e ora nel relativo DateTime equivalente. Tenta di analizzare completamente la stringa di input senza generare un'eccezione FormatException.
Importante
Se l'operazione di analisi non riesce a causa di un formato stringa non riconosciuto, il metodo Parse genera un FormatException, mentre il metodo TryParse restituisce false
. Poiché la gestione delle eccezioni può essere costosa, è consigliabile usare Parse quando si prevede che l'operazione di analisi abbia esito positivo perché l'origine di input è attendibile.
TryParse è preferibile quando gli errori di analisi sono probabilmente, in particolare perché un'origine di input non è attendibile o si dispone di valori predefiniti ragionevoli da sostituire con le stringhe che non analizzano correttamente.
La stringa da analizzare può assumere una delle forme seguenti:
Stringa con un componente di data e ora.
Stringa con una data ma nessun componente di ora. Se il componente ora è assente, il metodo presuppone 12:00 mezzanotte. Se il componente date ha un anno a due cifre, viene convertito in un anno in base al Calendar.TwoDigitYearMax del calendario corrente delle impostazioni cultura correnti o al calendario corrente delle impostazioni cultura specificate (se si usa un overload con un argomento
provider
non Null).Stringa con un componente di data che include solo il mese e l'anno, ma nessun componente giorno. Il metodo presuppone il primo giorno del mese.
Stringa con un componente di data che include solo il mese e il giorno, ma nessun componente dell'anno. Il metodo presuppone l'anno corrente.
Stringa con un'ora ma nessun componente di data. Il metodo presuppone la data corrente a meno che non venga chiamato l'overload Parse(String, IFormatProvider, DateTimeStyles) e includa DateTimeStyles.NoCurrentDateDefault nell'argomento
styles
, nel qual caso il metodo presuppone una data del 1° gennaio 0001.Stringa con un componente di ora che include solo l'ora e un designatore AM/PM, senza componente data. Il metodo presuppone la data corrente e un'ora senza minuti e nessun secondo. È possibile modificare questo comportamento chiamando l'overload Parse(String, IFormatProvider, DateTimeStyles) e includere DateTimeStyles.NoCurrentDateDefault nell'argomento
styles
, nel qual caso il metodo presuppone una data del 1° gennaio 0001.Stringa che include le informazioni sul fuso orario e è conforme a ISO 8601. Negli esempi seguenti la prima stringa designa l'ora UTC (Coordinated Universal Time) e la seconda designa l'ora in un fuso orario di sette ore prima dell'ora UTC:
"2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.0000000-07:00"
Stringa che include l'identificatore GMT ed è conforme al formato di ora RFC 1123; Per esempio:
"Sat, 01 Nov 2008 19:35:00 GMT"
Stringa che include la data e l'ora insieme alle informazioni sulla differenza di fuso orario; Per esempio:
"03/01/2009 05:42:00 -5:00"
Nell'esempio seguente vengono analizzate le stringhe in ognuno di questi formati usando le convenzioni di formattazione delle impostazioni cultura correnti, che in questo caso sono le impostazioni cultura en-US:
using System;
public class Example
{
public static void Main()
{
(string dateAsString, string description)[] dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),
("08/18/2018", "String with a date component only"),
("8/2018", "String with a month and year component only"),
("8/18", "String with a month and day component only"),
("07:22:16", "String with a time component only"),
("7 PM", "String with an hour and AM/PM designator only"),
("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };
Console.WriteLine($"Today is {DateTime.Now:d}\n");
foreach (var item in dateInfo) {
Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");
}
}
}
// The example displays output like the following:
// Today is 2/22/2018
//
// String with a date and time component: '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
// String with a date component only: '08/18/2018' --> 8/18/2018 12:00:00 AM
// String with a month and year component only: '8/2018' --> 8/1/2018 12:00:00 AM
// String with a month and day component only: '8/18' --> 8/18/2018 12:00:00 AM
// String with a time component only: '07:22:16' --> 2/22/2018 7:22:16 AM
// String with an hour and AM/PM designator only: '7 PM' --> 2/22/2018 7:00:00 PM
// UTC string that conforms to ISO 8601: '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
// Non-UTC string that conforms to ISO 8601: '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
// String that conforms to RFC 1123: 'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
// String with date, time, and time zone information: '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM
module Parse6
open System
let dateInfo =
[ "08/18/2018 07:22:16", "String with a date and time component"
"08/18/2018", "String with a date component only"
"8/2018", "String with a month and year component only"
"8/18", "String with a month and day component only"
"07:22:16", "String with a time component only"
"7 PM", "String with an hour and AM/PM designator only"
"2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"
"2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"
"Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"
"08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ]
printfn $"Today is {DateTime.Now:d}\n"
for dateAsString, description in dateInfo do
printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(dateAsString)}"""
// The example displays output like the following:
// Today is 2/22/2018
//
// String with a date and time component: '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
// String with a date component only: '08/18/2018' --> 8/18/2018 12:00:00 AM
// String with a month and year component only: '8/2018' --> 8/1/2018 12:00:00 AM
// String with a month and day component only: '8/18' --> 8/18/2018 12:00:00 AM
// String with a time component only: '07:22:16' --> 2/22/2018 7:22:16 AM
// String with an hour and AM/PM designator only: '7 PM' --> 2/22/2018 7:00:00 PM
// UTC string that conforms to ISO 8601: '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
// Non-UTC string that conforms to ISO 8601: '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
// String that conforms to RFC 1123: 'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
// String with date, time, and time zone information: '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM
Public Module Strings
Public Sub Main()
Dim dateInfo() As (dateAsString As String, description As String) =
{ ("08/18/2018 07:22:16", "String with a date and time component"),
("08/18/2018", "String with a date component only"),
("8/2018", "String with a month and year component only"),
("8/18", "String with a month and day component only"),
("07:22:16", "String with a time component only"),
("7 PM", "String with an hour and AM/PM designator only"),
("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
For Each item in dateInfo
Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")
Next
End Sub
End Module
' The example displays output like the following:
' Today is 2/22/2018
'
' String with a date and time component: '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
' String with a date component only: '08/18/2018' --> 8/18/2018 12:00:00 AM
' String with a month and year component only: '8/2018' --> 8/1/2018 12:00:00 AM
' String with a month and day component only: '8/18' --> 8/18/2018 12:00:00 AM
' String with a time component only: '07:22:16' --> 2/22/2018 7:22:16 AM
' String with an hour and AM/PM designator only: '7 PM' --> 2/22/2018 7:00:00 PM
' UTC string that conforms to ISO 8601: '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
' Non-UTC string that conforms to ISO 8601: '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
' String that conforms to RFC 1123: 'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
' String with date, time, and time zone information: '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM
Se la stringa di input rappresenta un giorno bisestile nel calendario usato dal metodo di analisi (vedere Convenzioni di analisi e cultura), il metodo Parse analizza correttamente la stringa. Se la stringa di input rappresenta un giorno bisestile in un anno non bisestile, il metodo genera un FormatException.
Poiché il metodo Parse tenta di analizzare la rappresentazione di stringa di una data e ora usando le regole di formattazione delle impostazioni cultura correnti o specificate, il tentativo di analizzare una stringa tra impostazioni cultura diverse può non riuscire. Per analizzare un formato di data e ora specifico in impostazioni locali diverse, usare uno degli overload del metodo DateTime.ParseExact e fornire un identificatore di formato.
Tutti gli overload del metodo Parse sono sensibili alle impostazioni cultura, a meno che la stringa da analizzare (rappresentata da s
nella tabella seguente) non sia conforme al modello ISO 8601. L'operazione di analisi usa le informazioni di formattazione in un oggetto DateTimeFormatInfo derivato nel modo seguente:
Importante
Le ere nei calendari giapponesi si basano sul regno dell'imperatore e quindi si prevede di cambiare. Ad esempio, il 1° maggio 2019 ha contrassegnato l'inizio dell'era Reiwa nel JapaneseCalendar e JapaneseLunisolarCalendar. Tale cambiamento di era influisce su 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à alla modifica dell'era, vedere Preparare l'applicazione per la modifica 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.
Se si chiama | E provider è |
Le informazioni di formattazione derivano da |
---|---|---|
Parse(String) | - | Impostazioni cultura correnti ( proprietàDateTimeFormatInfo.CurrentInfo) |
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) | un oggetto DateTimeFormatInfo | Oggetto DateTimeFormatInfo specificato |
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) | null |
Impostazioni cultura correnti ( proprietàDateTimeFormatInfo.CurrentInfo) |
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) | un oggetto CultureInfo | Proprietà CultureInfo.DateTimeFormat |
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) | Implementazione di IFormatProvider personalizzata | Metodo IFormatProvider.GetFormat |
Quando le informazioni di formattazione derivano da un oggetto DateTimeFormatInfo, la proprietà DateTimeFormatInfo.Calendar definisce il calendario utilizzato nell'operazione di analisi.
Se si analizza una stringa di data e ora usando un oggetto DateTimeFormatInfo con impostazioni personalizzate diverse da quelle delle impostazioni cultura standard, usare il metodo ParseExact anziché il metodo Parse per migliorare le probabilità di una conversione riuscita. Una stringa di data e ora non standard può essere complessa e difficile da analizzare. Il metodo Parse tenta di analizzare una stringa con diversi modelli di analisi impliciti, che potrebbero avere esito negativo. Al contrario, il metodo ParseExact richiede di designare in modo esplicito uno o più modelli di analisi esatti che potrebbero avere esito positivo. Per altre informazioni, vedere la sezione "DateTimeFormatInfo e Dynamic Data" nell'argomento DateTimeFormatInfo.
Importante
Si noti che le convenzioni di formattazione per una determinata cultura sono dinamiche e possono essere soggette a modifiche. Ciò significa che le operazioni di analisi che dipendono dalle convenzioni di formattazione delle impostazioni cultura predefinite (correnti) o che specificano un oggetto IFormatProvider che rappresenta impostazioni cultura diverse dalle impostazioni cultura invarianti possono non riuscire in modo imprevisto se si verifica una delle condizioni seguenti:
- I dati specifici delle impostazioni cultura sono stati modificati tra versioni principali o secondarie di .NET Framework o come risultato di un aggiornamento alla versione esistente di .NET Framework.
- I dati specifici delle impostazioni cultura riflettono le preferenze utente, che possono variare da computer a computer o sessione alla sessione.
- I dati specifici delle impostazioni cultura rappresentano impostazioni cultura di sostituzione che eseguono l'override delle impostazioni di impostazioni cultura standard o impostazioni cultura personalizzate.
Per evitare le difficoltà nell'analisi di stringhe di dati e ora associate alle modifiche apportate ai dati culturali, è possibile analizzare le stringhe di data e ora usando le impostazioni cultura invarianti oppure chiamare il metodo ParseExact o TryParseExact e specificare il formato esatto della stringa da analizzare. Se si serializzano e deserializzano i dati di data e ora, è possibile utilizzare le convenzioni di formattazione delle impostazioni cultura invarianti oppure serializzare e deserializzare il valore DateTime in un formato binario.
Per altre informazioni, vedere la sezione "Dynamic culture data" nell'argomento CultureInfo e la sezione "Persisting DateTime values" nell'argomento DateTime.
Tutti gli overload Parse ignorano gli spazi vuoti iniziali, interni o finali nella stringa di input , rappresentato da s
nella tabella seguente. La data e l'ora possono essere racchiuse tra parentesi con una coppia di caratteri NUMERO iniziale e finale ("#", U+0023) e possono essere terminati con uno o più caratteri NULL (U+0000).
Inoltre, l'overload Parse(String, IFormatProvider, DateTimeStyles) include un parametro styles
costituito da uno o più membri dell'enumerazione DateTimeStyles. Questo parametro definisce come deve essere interpretato s
e come l'operazione di analisi deve convertire s
in una data e un'ora. Nella tabella seguente viene descritto l'effetto di ogni membro DateTimeStyles nell'operazione di analisi.
Membro DateTimeStyles | Effetto sulla conversione |
---|---|
AdjustToUniversal | Analizza s e, se necessario, lo converte in formato UTC, come indicato di seguito:- Se s include una differenza di fuso orario o se s non contiene informazioni sul fuso orario, ma styles include il flag AssumeLocal, il metodo analizza la stringa, chiama ToUniversalTime per convertire il valore DateTime restituito in utc e imposta la proprietà Kind su DateTimeKind.Utc.- Se s indica che rappresenta l'ora UTC o se s non contiene informazioni sul fuso orario, ma styles include il flag AssumeUniversal, il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore DateTime restituito e imposta la proprietà Kind su DateTimeKind.Utc.- In tutti gli altri casi, il flag non ha alcun effetto. |
AllowInnerWhite | Questo valore viene ignorato. Gli spazi vuoti interni sono sempre consentiti negli elementi di data e ora di s . |
AllowLeadingWhite | Questo valore viene ignorato. Gli spazi vuoti iniziali sono sempre consentiti negli elementi di data e ora di s . |
AllowTrailingWhite | Questo valore viene ignorato. Gli spazi vuoti finali sono sempre consentiti negli elementi di data e ora di s . |
AllowWhiteSpaces | Specifica che s può contenere spazi vuoti iniziali, interni e finali. Si tratta del comportamento predefinito. Non può essere sottoposto a override fornendo un valore di enumerazione DateTimeStyles più restrittivo, ad esempio None. |
AssumeLocal | Specifica che se s non dispone di informazioni sul fuso orario, si presuppone l'ora locale. A meno che il flag di AdjustToUniversal non sia presente, la proprietà Kind del valore DateTime restituito è impostata su DateTimeKind.Local. |
AssumeUniversal | Specifica che se s non dispone di informazioni sul fuso orario, si presuppone l'ora UTC. A meno che il flag AdjustToUniversal non sia presente, il metodo converte il valore DateTime restituito dall'ora UTC all'ora locale e imposta la relativa proprietà Kind in DateTimeKind.Local. |
None | Anche se valido, questo valore viene ignorato. |
RoundtripKind | Per le stringhe che contengono informazioni sul fuso orario, tenta di impedire la conversione di una stringa di data e ora in un valore di DateTime che rappresenta un'ora locale con la relativa proprietà Kind impostata su DateTimeKind.Local. In genere, tale stringa viene creata chiamando il metodo DateTime.ToString(String) e usando l'identificatore di formato standard "o", "r" o "u". |
Gli overload DateTime.Parse
restituiscono un valore DateTime la cui proprietà Kind include informazioni sul fuso orario. Può indicare che l'ora è:
- Coordinated Universal Time (System.DateTimeKind.Utc).
- Ora nel fuso orario locale (System.DateTimeKind.Local).
- Ora in un fuso orario sconosciuto (System.DateTimeKind.Unspecified).
In genere, il metodo Parse restituisce un oggetto DateTime la cui proprietà Kind è DateTimeKind.Unspecified. Tuttavia, il metodo Parse può anche eseguire la conversione del fuso orario e impostare il valore della proprietà Kind in modo diverso, a seconda dei valori dei parametri s
e styles
:
Se | Conversione del fuso orario | Kind - proprietà |
---|---|---|
s contiene informazioni sul fuso orario. |
La data e l'ora vengono convertite nell'ora nel fuso orario locale. | DateTimeKind.Local |
s contiene informazioni sul fuso orario e styles include il flag di AdjustToUniversal. |
La data e l'ora vengono convertite in utc (Coordinated Universal Time). | DateTimeKind.Utc |
s contiene l'indicatore di fuso orario Z o GMT e styles include il flag RoundtripKind. |
La data e l'ora vengono interpretate come UTC. | DateTimeKind.Utc |
L'esempio seguente converte le stringhe di data che contengono informazioni sul fuso orario nell'ora nel fuso orario locale:
using System;
public class Example
{
public static void Main()
{
string[] dateStrings = {"2008-05-01T07:34:42-5:00",
"2008-05-01 7:34:42Z",
"Thu, 01 May 2008 07:34:42 GMT"};
foreach (string dateString in dateStrings)
{
DateTime convertedDate = DateTime.Parse(dateString);
Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
}
}
}
// These calls to the DateTime.Parse method display the following output:
// Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
// Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
// Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM
open System
let dateStrings =
[ "2008-05-01T07:34:42-5:00"
"2008-05-01 7:34:42Z"
"Thu, 01 May 2008 07:34:42 GMT" ]
for dateString in dateStrings do
let convertedDate = DateTime.Parse dateString
printfn $"Converted {dateString} to {convertedDate.Kind} time {convertedDate}"
// These calls to the DateTime.Parse method display the following output:
// Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
// Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
// Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM
Module Example
Public Sub Main()
Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00",
"2008-05-01 7:34:42Z",
"Thu, 01 May 2008 07:34:42 GMT"}
For Each dateStr In dateStrings
Dim convertedDate As Date = Date.Parse(dateStr)
Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
Next
End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
' Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
' Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
' Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM
È anche possibile mantenere il valore di una proprietà di data e ora Kind durante un'operazione di formattazione e analisi usando il flag DateTimeStyles.RoundtripKind. Nell'esempio seguente viene illustrato come il flag di RoundtripKind influisce sull'operazione di analisi sui valori DateTime convertiti in stringhe usando l'identificatore di formato "o", "r" o "u".
string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00",
"2008-09-15T09:30:41.7752486Z",
"2008-09-15T09:30:41.7752486",
"2008-09-15T09:30:41.7752486-04:00",
"Mon, 15 Sep 2008 09:30:41 GMT" };
foreach (string formattedDate in formattedDates)
{
Console.WriteLine(formattedDate);
DateTime roundtripDate = DateTime.Parse(formattedDate, null,
DateTimeStyles.RoundtripKind);
Console.WriteLine($" With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");
DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
DateTimeStyles.None);
Console.WriteLine($" Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
}
// The example displays the following output:
// 2008-09-15T09:30:41.7752486-07:00
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
// Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
// 2008-09-15T09:30:41.7752486Z
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
// Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
// 2008-09-15T09:30:41.7752486
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
// Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
// 2008-09-15T09:30:41.7752486-04:00
// With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
// Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
// Mon, 15 Sep 2008 09:30:41 GMT
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
// Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
let formattedDates =
[ "2008-09-15T09:30:41.7752486-07:00"
"2008-09-15T09:30:41.7752486Z"
"2008-09-15T09:30:41.7752486"
"2008-09-15T09:30:41.7752486-04:00"
"Mon, 15 Sep 2008 09:30:41 GMT" ]
for formattedDate in formattedDates do
printfn $"{formattedDate}"
let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
printfn $" With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."
let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
printfn $" Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time."
// The example displays the following output:
// 2008-09-15T09:30:41.7752486-07:00
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
// Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
// 2008-09-15T09:30:41.7752486Z
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
// Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
// 2008-09-15T09:30:41.7752486
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
// Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
// 2008-09-15T09:30:41.7752486-04:00
// With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
// Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
// Mon, 15 Sep 2008 09:30:41 GMT
// With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
// Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00",
"2008-09-15T09:30:41.7752486Z",
"2008-09-15T09:30:41.7752486",
"2008-09-15T09:30:41.7752486-04:00",
"Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
Console.WriteLine(formattedDate)
Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,
DateTimeStyles.RoundtripKind)
Console.WriteLine($" With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")
Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing, DateTimeStyles.None)
Console.WriteLine($" Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next
' The example displays the following output:
' 2008-09-15T09:30:41.7752486-07:00
' With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
' Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
' 2008-09-15T09:30:41.7752486Z
' With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
' Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
' 2008-09-15T09:30:41.7752486
' With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
' Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
' 2008-09-15T09:30:41.7752486-04:00
' With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
' Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
' Mon, 15 Sep 2008 09:30:41 GMT
' With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
' Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
Converte la rappresentazione di stringa di una data e un'ora nel relativo DateTime equivalente usando le convenzioni delle impostazioni cultura correnti.
public:
static DateTime Parse(System::String ^ s);
public static DateTime Parse (string s);
static member Parse : string -> DateTime
Public Shared Function Parse (s As String) As DateTime
Parametri
- s
- String
Stringa contenente una data e un'ora da convertire. Per altre informazioni, vedere Stringa da analizzare.
Restituisce
Oggetto equivalente alla data e all'ora contenute in s
.
Eccezioni
s
è null
.
s
non contiene una rappresentazione di stringa valida di una data e un'ora.
Esempio
L'esempio seguente analizza la rappresentazione di stringa di diversi valori di data e ora in base a:
Utilizzando il provider di formato predefinito, che fornisce le convenzioni di formattazione delle impostazioni cultura correnti del computer utilizzato per produrre l'output di esempio. L'output di questo esempio riflette le convenzioni di formattazione delle impostazioni cultura en-US.
Utilizzando il valore di stile predefinito, che è AllowWhiteSpaces.
Gestisce l'eccezione FormatException generata quando il metodo tenta di analizzare la rappresentazione di stringa di una data e di un'ora usando le convenzioni di formattazione di altre impostazioni cultura. Viene inoltre illustrato come analizzare correttamente un valore di data e ora che non usa le convenzioni di formattazione delle impostazioni cultura correnti.
using System;
using System.Globalization;
public class DateTimeParser
{
public static void Main()
{
// Assume the current culture is en-US.
// The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
// Use standard en-US date and time value
DateTime dateValue;
string dateString = "2/16/2008 12:15:12 PM";
try {
dateValue = DateTime.Parse(dateString);
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
}
catch (FormatException) {
Console.WriteLine("Unable to convert '{0}'.", dateString);
}
// Reverse month and day to conform to the fr-FR culture.
// The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
dateString = "16/02/2008 12:15:12";
try {
dateValue = DateTime.Parse(dateString);
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
}
catch (FormatException) {
Console.WriteLine("Unable to convert '{0}'.", dateString);
}
// Call another overload of Parse to successfully convert string
// formatted according to conventions of fr-FR culture.
try {
dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
}
catch (FormatException) {
Console.WriteLine("Unable to convert '{0}'.", dateString);
}
// Parse string with date but no time component.
dateString = "2/16/2008";
try {
dateValue = DateTime.Parse(dateString);
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
}
catch (FormatException) {
Console.WriteLine("Unable to convert '{0}'.", dateString);
}
}
}
// The example displays the following output to the console:
// '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
// Unable to convert '16/02/2008 12:15:12'.
// '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
// '2/16/2008' converted to 2/16/2008 12:00:00 AM.
open System
open System.Globalization
[<EntryPoint>]
let main _ =
// Assume the current culture is en-US.
// The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
// Use standard en-US date and time value
let dateString = "2/16/2008 12:15:12 PM"
try
let dateValue = DateTime.Parse dateString
printfn $"'{dateString}' converted to {dateValue}."
with :? FormatException ->
printfn $"Unable to convert '{dateString}'."
// Reverse month and day to conform to the fr-FR culture.
// The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
let dateString = "16/02/2008 12:15:12"
try
let dateValue = DateTime.Parse dateString
printfn $"'{dateString}' converted to {dateValue}."
with :? FormatException ->
Console.WriteLine("Unable to convert '{0}'.", dateString)
// Call another overload of Parse to successfully convert string
// formatted according to conventions of fr-FR culture.
try
let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
printfn $"'{dateString}' converted to {dateValue}."
with :? FormatException ->
printfn $"Unable to convert '{dateString}'."
// Parse string with date but no time component.
let dateString = "2/16/2008"
try
let dateValue = DateTime.Parse dateString
printfn $"'{dateString}' converted to {dateValue}."
with :? FormatException ->
printfn $"Unable to convert '{dateString}'."
0
// The example displays the following output to the console:
// '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
// Unable to convert '16/02/2008 12:15:12'.
// '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
// '2/16/2008' converted to 2/16/2008 12:00:00 AM.
Imports System.Globalization
Class DateTimeParser
Public Shared Sub Main()
' Assume the current culture is en-US.
' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
' Use standard en-US date and time value
Dim dateValue As Date
Dim dateString As String = "2/16/2008 12:15:12 PM"
Try
dateValue = Date.Parse(dateString)
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}'.", dateString)
End Try
' Reverse month and day to conform to the fr-FR culture.
' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
dateString = "16/02/2008 12:15:12"
Try
dateValue = Date.Parse(dateString)
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}'.", dateString)
End Try
' Call another overload of Parse to successfully convert string
' formatted according to conventions of fr-FR culture.
Try
dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}'.", dateString)
End Try
' Parse string with date but no time component.
dateString = "2/16/2008"
Try
dateValue = Date.Parse(dateString)
Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
Catch e As FormatException
Console.WriteLine("Unable to convert '{0}'.", dateString)
End Try
End Sub
End Class
' The example displays the following output to the console:
' '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
' Unable to convert '16/02/2008 12:15:12'.
' '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
' '2/16/2008' converted to 2/16/2008 12:00:00 AM.
Commenti
Se s
contiene informazioni sul fuso orario, questo metodo restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Local e converte la data e l'ora in s
in ora locale. In caso contrario, non esegue alcuna conversione del fuso orario e restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Unspecified.
Questo overload tenta di analizzare s
usando le convenzioni di formattazione delle impostazioni cultura correnti. Le impostazioni cultura correnti sono indicate dalla proprietà CurrentCulture. Per analizzare una stringa usando le convenzioni di formattazione di impostazioni cultura specifiche, chiamare l'Parse(String, IFormatProvider) o gli overload Parse(String, IFormatProvider, DateTimeStyles).
Questo overload tenta di analizzare s
usando lo stile di DateTimeStyles.AllowWhiteSpaces.
Vedi anche
- TryParse
- CultureInfo
- DateTimeFormatInfo
- l'analisi di stringhe di data e ora in .NET Framework
- stringhe di formato data e ora standard
- stringhe di formato di data e ora personalizzate
Si applica a
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
Analizza un intervallo di caratteri in un valore.
public:
static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime
Parametri
- s
- ReadOnlySpan<Char>
Intervallo di caratteri da analizzare.
- provider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s
.
Restituisce
Risultato dell'analisi s
.
Implementazioni
Si applica a
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
Converte la rappresentazione di stringa di una data e un'ora nel relativo DateTime equivalente usando informazioni sul formato specifiche delle impostazioni cultura.
public:
static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public:
static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;
public static DateTime Parse (string s, IFormatProvider provider);
public static DateTime Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime
Parametri
- s
- String
Stringa contenente una data e un'ora da convertire. Per altre informazioni, vedere Stringa da analizzare.
- provider
- IFormatProvider
Oggetto che fornisce informazioni sul formato specifiche delle impostazioni cultura su s
. Vedere Convenzioni di analisi e cultura
Restituisce
Oggetto equivalente alla data e all'ora contenute in s
come specificato da provider
.
Implementazioni
Eccezioni
s
è null
.
s
non contiene una rappresentazione di stringa valida di una data e un'ora.
Esempio
Nell'esempio seguente viene analizzata una matrice di stringhe di data usando le convenzioni delle impostazioni cultura en-US, fr-FRe de-DE. Dimostra che le rappresentazioni di stringa di una singola data possono essere interpretate in modo diverso tra impostazioni cultura diverse.
using System;
using System.Globalization;
public class ParseDate
{
public static void Main()
{
// Define cultures to be used to parse dates.
CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
CultureInfo.CreateSpecificCulture("fr-FR"),
CultureInfo.CreateSpecificCulture("de-DE")};
// Define string representations of a date to be parsed.
string[] dateStrings = {"01/10/2009 7:34 PM",
"10.01.2009 19:34",
"10-1-2009 19:34" };
// Parse dates using each culture.
foreach (CultureInfo culture in cultures)
{
DateTime dateValue;
Console.WriteLine("Attempted conversions using {0} culture.",
culture.Name);
foreach (string dateString in dateStrings)
{
try {
dateValue = DateTime.Parse(dateString, culture);
Console.WriteLine(" Converted '{0}' to {1}.",
dateString, dateValue.ToString("f", culture));
}
catch (FormatException) {
Console.WriteLine(" Unable to convert '{0}' for culture {1}.",
dateString, culture.Name);
}
}
Console.WriteLine();
}
}
}
// The example displays the following output to the console:
// Attempted conversions using en-US culture.
// Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
// Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
// Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
// Attempted conversions using fr-FR culture.
// Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
// Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
// Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
// Attempted conversions using de-DE culture.
// Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
// Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
// Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
open System
open System.Globalization
// Define cultures to be used to parse dates.
let cultures =
[ CultureInfo.CreateSpecificCulture "en-US"
CultureInfo.CreateSpecificCulture "fr-FR"
CultureInfo.CreateSpecificCulture "de-DE" ]
// Define string representations of a date to be parsed.
let dateStrings =
[ "01/10/2009 7:34 PM"
"10.01.2009 19:34"
"10-1-2009 19:34" ]
// Parse dates using each culture.
for culture in cultures do
printfn $"Attempted conversions using {culture.Name} culture."
for dateString in dateStrings do
try
let dateValue = DateTime.Parse(dateString, culture)
printfn $""" Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
with :? FormatException ->
printfn $" Unable to convert '{dateString}' for culture {culture.Name}."
printfn ""
// The example displays the following output to the console:
// Attempted conversions using en-US culture.
// Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
// Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
// Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
// Attempted conversions using fr-FR culture.
// Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
// Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
// Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
// Attempted conversions using de-DE culture.
// Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
// Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
// Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
Imports System.Globalization
Module ParseDate
Public Sub Main()
' Define cultures to be used to parse dates.
Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
CultureInfo.CreateSpecificCulture("fr-FR"), _
CultureInfo.CreateSpecificCulture("de-DE")}
' Define string representations of a date to be parsed.
Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
"10.01.2009 19:34", _
"10-1-2009 19:34" }
' Parse dates using each culture.
For Each culture In cultures
Dim dateValue As Date
Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
For Each dateString As String In dateStrings
Try
dateValue = Date.Parse(dateString, culture)
Console.WriteLine(" Converted '{0}' to {1}.", _
dateString, dateValue.ToString("f", culture))
Catch e As FormatException
Console.WriteLine(" Unable to convert '{0}' for culture {1}.", _
dateString, culture.Name)
End Try
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output to the console:
' Attempted conversions using en-US culture.
' Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
' Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
' Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'
' Attempted conversions using fr-FR culture.
' Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
' Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
' Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'
' Attempted conversions using de-DE culture.
' Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
' Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
' Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
Commenti
Se s
contiene informazioni sul fuso orario, questo metodo restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Local e converte la data e l'ora in s
in ora locale. In caso contrario, non esegue alcuna conversione del fuso orario e restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Unspecified.
Questo overload tenta di analizzare s
usando lo stile DateTimeStyles.AllowWhiteSpaces.
Vedi anche
- TryParse
- CultureInfo
- DateTimeFormatInfo
- l'analisi di stringhe di data e ora in .NET Framework
- stringhe di formato data e ora standard
- stringhe di formato di data e ora personalizzate
Si applica a
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
Converte un intervallo di memoria che contiene la rappresentazione di stringa di una data e dell'ora nel relativo DateTime equivalente utilizzando informazioni di formato specifiche delle impostazioni cultura e uno stile di formattazione.
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime
Parametri
- s
- ReadOnlySpan<Char>
Intervallo di memoria che contiene la stringa da analizzare. Per altre informazioni, vedere Stringa da analizzare.
- provider
- IFormatProvider
Oggetto che fornisce informazioni sul formato specifiche delle impostazioni cultura su s
. Vedere Convenzioni di analisi e cultura
- styles
- DateTimeStyles
Combinazione bit per bit dei valori di enumerazione che indica gli elementi di stile che possono essere presenti in s
affinché l'operazione di analisi abbia esito positivo e che definisce come interpretare la data analizzata in relazione al fuso orario corrente o alla data corrente. Un valore tipico da specificare è None.
Restituisce
Oggetto equivalente alla data e all'ora contenute in s
, come specificato da provider
e styles
.
Eccezioni
s
non contiene una rappresentazione di stringa valida di una data e un'ora.
styles
contiene una combinazione non valida di valori di DateTimeStyles. Ad esempio, sia AssumeLocal che AssumeUniversal.
Si applica a
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
- Origine:
- DateTime.cs
Converte la rappresentazione di stringa di una data e un'ora nel relativo DateTime equivalente usando informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione.
public:
static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles);
static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime
Parametri
- s
- String
Stringa contenente una data e un'ora da convertire. Per altre informazioni, vedere Stringa da analizzare.
- provider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s
. Vedere Convenzioni di analisi e cultura
- styles
- DateTimeStyles
Combinazione bit per bit dei valori di enumerazione che indica gli elementi di stile che possono essere presenti in s
affinché l'operazione di analisi abbia esito positivo e che definisce come interpretare la data analizzata in relazione al fuso orario corrente o alla data corrente. Un valore tipico da specificare è None.
Restituisce
Oggetto equivalente alla data e all'ora contenute in s
, come specificato da provider
e styles
.
Eccezioni
s
è null
.
s
non contiene una rappresentazione di stringa valida di una data e un'ora.
styles
contiene una combinazione non valida di valori di DateTimeStyles. Ad esempio, sia AssumeLocal che AssumeUniversal.
Esempio
Nell'esempio seguente viene illustrato il metodo Parse(String, IFormatProvider, DateTimeStyles) e viene visualizzato il valore della proprietà Kind dei valori DateTime risultanti.
using System;
using System.Globalization;
public class ParseDateExample
{
public static void Main()
{
string dateString;
CultureInfo culture ;
DateTimeStyles styles;
DateTime result;
// Parse a date and time with no styles.
dateString = "03/01/2009 10:00 AM";
culture = CultureInfo.CreateSpecificCulture("en-US");
styles = DateTimeStyles.None;
try {
result = DateTime.Parse(dateString, culture, styles);
Console.WriteLine("{0} converted to {1} {2}.",
dateString, result, result.Kind.ToString());
}
catch (FormatException) {
Console.WriteLine("Unable to convert {0} to a date and time.",
dateString);
}
// Parse the same date and time with the AssumeLocal style.
styles = DateTimeStyles.AssumeLocal;
try {
result = DateTime.Parse(dateString, culture, styles);
Console.WriteLine("{0} converted to {1} {2}.",
dateString, result, result.Kind.ToString());
}
catch (FormatException) {
Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
}
// Parse a date and time that is assumed to be local.
// This time is five hours behind UTC. The local system's time zone is
// eight hours behind UTC.
dateString = "2009/03/01T10:00:00-5:00";
styles = DateTimeStyles.AssumeLocal;
try {
result = DateTime.Parse(dateString, culture, styles);
Console.WriteLine("{0} converted to {1} {2}.",
dateString, result, result.Kind.ToString());
}
catch (FormatException) {
Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
}
// Attempt to convert a string in improper ISO 8601 format.
dateString = "03/01/2009T10:00:00-5:00";
try {
result = DateTime.Parse(dateString, culture, styles);
Console.WriteLine("{0} converted to {1} {2}.",
dateString, result, result.Kind.ToString());
}
catch (FormatException) {
Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
}
// Assume a date and time string formatted for the fr-FR culture is the local
// time and convert it to UTC.
dateString = "2008-03-01 10:00";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
try {
result = DateTime.Parse(dateString, culture, styles);
Console.WriteLine("{0} converted to {1} {2}.",
dateString, result, result.Kind.ToString());
}
catch (FormatException) {
Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
}
}
}
// The example displays the following output to the console:
// 03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
// 03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
// 2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
// Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
// 2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
open System
open System.Globalization
[<EntryPoint>]
let main _ =
// Parse a date and time with no styles.
let dateString = "03/01/2009 10:00 AM"
let culture = CultureInfo.CreateSpecificCulture "en-US"
let styles = DateTimeStyles.None
try
let result = DateTime.Parse(dateString, culture, styles)
printfn $"{dateString} converted to {result} {result.Kind}."
with :? FormatException ->
printfn $"Unable to convert {dateString} to a date and time."
// Parse the same date and time with the AssumeLocal style.
let styles = DateTimeStyles.AssumeLocal
try
let result = DateTime.Parse(dateString, culture, styles)
printfn $"{dateString} converted to {result} {result.Kind}."
with :? FormatException ->
printfn $"Unable to convert {dateString} to a date and time."
// Parse a date and time that is assumed to be local.
// This time is five hours behind UTC. The local system's time zone is
// eight hours behind UTC.
let dateString = "2009/03/01T10:00:00-5:00"
let styles = DateTimeStyles.AssumeLocal
try
let result = DateTime.Parse(dateString, culture, styles)
printfn $"{dateString} converted to {result} {result.Kind}."
with :? FormatException ->
printfn $"Unable to convert {dateString} to a date and time."
// Attempt to convert a string in improper ISO 8601 format.
let dateString = "03/01/2009T10:00:00-5:00"
try
let result = DateTime.Parse(dateString, culture, styles)
printfn $"{dateString} converted to {result} {result.Kind}."
with :? FormatException ->
printfn $"Unable to convert {dateString} to a date and time."
// Assume a date and time string formatted for the fr-FR culture is the local
// time and convert it to UTC.
let dateString = "2008-03-01 10:00"
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
try
let result = DateTime.Parse(dateString, culture, styles)
printfn $"{dateString} converted to {result} {result.Kind}."
with :? FormatException ->
printfn $"Unable to convert {dateString} to a date and time."
0
// The example displays the following output to the console:
// 03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
// 03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
// 2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
// Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
// 2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
Imports System.Globalization
Module ParseDateExample
Public Sub Main()
Dim dateString As String
Dim culture As CultureInfo
Dim styles As DateTimeStyles
Dim result As DateTime
' Parse a date and time with no styles.
dateString = "03/01/2009 10:00 AM"
culture = CultureInfo.CreateSpecificCulture("en-US")
styles = DateTimeStyles.None
Try
result = DateTime.Parse(dateString, culture, styles)
Console.WriteLine("{0} converted to {1} {2}.", _
dateString, result, result.Kind.ToString())
Catch e As FormatException
Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
End Try
' Parse the same date and time with the AssumeLocal style.
styles = DateTimeStyles.AssumeLocal
Try
result = DateTime.Parse(dateString, culture, styles)
Console.WriteLine("{0} converted to {1} {2}.", _
dateString, result, result.Kind.ToString())
Catch e As FormatException
Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
End Try
' Parse a date and time that is assumed to be local.
' This time is five hours behind UTC. The local system's time zone is
' eight hours behind UTC.
dateString = "2009/03/01T10:00:00-5:00"
styles = DateTimeStyles.AssumeLocal
Try
result = DateTime.Parse(dateString, culture, styles)
Console.WriteLine("{0} converted to {1} {2}.", _
dateString, result, result.Kind.ToString())
Catch e As FormatException
Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
End Try
' Attempt to convert a string in improper ISO 8601 format.
dateString = "03/01/2009T10:00:00-5:00"
Try
result = DateTime.Parse(dateString, culture, styles)
Console.WriteLine("{0} converted to {1} {2}.", _
dateString, result, result.Kind.ToString())
Catch e As FormatException
Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
End Try
' Assume a date and time string formatted for the fr-FR culture is the local
' time and convert it to UTC.
dateString = "2008-03-01 10:00"
culture = CultureInfo.CreateSpecificCulture("fr-FR")
styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
Try
result = DateTime.Parse(dateString, culture, styles)
Console.WriteLine("{0} converted to {1} {2}.", _
dateString, result, result.Kind.ToString())
Catch e As FormatException
Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
End Try
End Sub
End Module
'
' The example displays the following output to the console:
' 03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
' 03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
' 2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
' Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
' 2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.
Commenti
Questo metodo esegue la conversione della data e dell'ora in s
e imposta la proprietà Kind del valore DateTime restituito nel modo seguente:
Se | Conversione del fuso orario | Kind - proprietà |
---|---|---|
s non contiene informazioni sul fuso orario. |
Nessuno. | DateTimeKind.Unspecified |
s contiene informazioni sul fuso orario. |
All'ora nel fuso orario locale | DateTimeKind.Local |
s contiene informazioni sul fuso orario e styles include il flag di DateTimeStyles.AdjustToUniversal. |
Per l'ora UTC (Coordinated Universal Time) | DateTimeKind.Utc |
s contiene l'identificatore di fuso orario Z o GMT e styles include il DateTimeStyles.RoundtripKind. |
Nessuno. | DateTimeKind.Utc |
Vedi anche
- TryParse
- CultureInfo
- DateTimeFormatInfo
- l'analisi di stringhe di data e ora in .NET Framework
- stringhe di formato data e ora standard
- stringhe di formato di data e ora personalizzate
- Procedura: Valori di data e ora di andata e ritorno
Si applica a
Feedback su .NET
.NET è un progetto di open source. Selezionare un collegamento per fornire feedback: