DateTime.Parse Metodo

Definizione

Converte la rappresentazione di stringa di una data e di un'ora nell'equivalente DateTime.

Overload

Parse(String)

Converte la rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le convenzioni delle impostazioni cultura del thread corrente.

Parse(String, IFormatProvider)

Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo DateTime equivalente usando le informazioni sul formato relative alle impostazioni cultura specificate.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Converte un intervallo di memoria che contiene la rappresentazione stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione.

Parse(String, IFormatProvider, DateTimeStyles)

Converte la rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione.

Esempio

Numerosi esempi che chiamano il metodo sono intercambiati nella sezione Osservazioni di questo articolo e nella documentazione DateTime.Parse per i singoli DateTime.Parse overload.

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.

È anche possibile scaricare un set completo di esempi, inclusi in un progetto DateTime.Parse .NET Core per C#.

Commenti

Contenuto della sezione:

Quale metodo si chiama?

A Call
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. Parse(String, IFormatProvider) overload (vedere Analisi e convenzioni culturali)
Analizzare una stringa di data e ora con elementi di stile speciali, ad esempio spazi vuoti o 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 Parse(String, IFormatProvider, DateTimeStyles) l'overload con DateTimeStyles.RoundtripKind
Analizzare una stringa di data e ora in un formato fisso tra i limiti del computer (ed eventualmente culturali). DateTime.ParseExact metodo DateTime.TryParseExact o

Stringa da analizzare

Il Parse metodo tenta di convertire la rappresentazione di stringa di un valore di data e ora nell'equivalente. DateTime Tenta di analizzare completamente la stringa di input senza generare FormatException un'eccezione.

Importante

Se l'operazione di analisi non riesce a causa di un formato stringa non riconosciuto, il metodo genera Parse FormatException un' , mentre il TryParse metodo restituisce false . Poiché la gestione delle eccezioni può essere costosa, è consigliabile usare quando si prevede che l'operazione di analisi avrà esito Parse positivo perché l'origine di input è attendibile. TryParse è preferibile quando è probabile che si siano verificati errori di analisi, in particolare perché un'origine di input non è attendibile o si dispone di valori predefiniti ragionevoli da sostituire alle stringhe che non vengono analizzate correttamente.

La stringa da analizzare può assumere uno dei formati seguenti:

  • Stringa con un componente di data e ora.

  • Stringa con un componente di data ma senza ora. Se il componente dell'ora è assente, il metodo presuppone la mezzanotte 12:00. Se il componente date ha un anno a due cifre, viene convertito in un anno in base al calendario corrente delle impostazioni cultura correnti o al calendario corrente delle impostazioni cultura specificate (se si usa un overload con un argomento Calendar.TwoDigitYearMax non provider Null).

  • Stringa con un componente 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 data che include solo il componente mese e giorno ma nessun anno. Il metodo presuppone l'anno corrente.

  • Stringa con un componente ora ma senza data. Il metodo presuppone la data corrente a meno che non si chiami l'overload e si includa nell'argomento , nel qual caso il metodo presuppone una data del Parse(String, IFormatProvider, DateTimeStyles) DateTimeStyles.NoCurrentDateDefault 1° gennaio styles 0001.

  • Stringa con un componente 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 senza secondi. È possibile modificare questo comportamento chiamando l'overload e includendo nell'argomento , nel qual caso il metodo presuppone una data del Parse(String, IFormatProvider, DateTimeStyles) DateTimeStyles.NoCurrentDateDefault styles 1° gennaio 0001.

  • Stringa che include informazioni sul fuso orario ed è conforme a ISO 8601. Negli esempi seguenti la prima stringa definisce Coordinated Universal Time (UTC) e la seconda definisce l'ora in un fuso orario che è di sette ore prima dell'ora UTC:

    "2008-11-01T19:35:00.0000000Z"
    "2008-11-01T19:35:00.0000000-07:00"

  • Stringa che include il designatore GMT ed è conforme al formato ora RFC 1123. Per esempio:

    "Sab, 01 Nov 2008 19:35:00 GMT"

  • Stringa che include la data e l'ora insieme alle informazioni sulla offset del fuso orario. Per esempio:

    "03/01/2009 05:42:00 -5:00"

L'esempio seguente analizza 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

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 intercalare in un anno bisestile nel calendario usato dal metodo di analisi (vedere Analisie convenzioni culturali), il metodo analizza correttamente la Parse stringa. Se la stringa di input rappresenta un giorno intercalare in un anno non bisestile, il metodo genera un'eccezione FormatException .

Poiché il metodo tenta di analizzare la rappresentazione di stringa di una data e di un'ora usando le regole di formattazione delle impostazioni cultura correnti o specificate, il tentativo di analizzare una stringa tra impostazioni cultura diverse può avere Parse esito negativo. Per analizzare un formato di data e ora specifico in diverse impostazioni locali, usare uno degli overload del metodo e fornire DateTime.ParseExact un identificatore di formato.

Analisi e convenzioni culturali

Tutti gli overload del metodo sono sensibili alle impostazioni cultura a meno che la stringa da analizzare (rappresentata dalla tabella seguente) non sia conforme al modello Parse s ISO 8601. L'operazione di analisi usa le informazioni di formattazione in un DateTimeFormatInfo oggetto derivato nel modo seguente:

Importante

Le ere nel calendario giapponese sono basate sul regno dell'imperatore e pertanto è previsto che cambino. Ad esempio, il 1° maggio 2019 contraddistingue l'inizio dell'era Reiwa in JapaneseCalendar e JapaneseLunisolarCalendar. Questo cambio di era interessa tutte le applicazioni che usano questi calendari. Per altre informazioni e per determinare se le applicazioni sono interessate, vedere Gestione di una nuova era nel calendario giapponese in .NET. Per informazioni sul test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento di era, vedere Preparare l'applicazione per la modifica dell'era giapponese. Per le funzionalità in .NET che supportano calendari con più ere e per le procedure consigliate quando si lavora con calendari che supportano più ere, vedere Uso delle ere.

Se si chiama Ed provider è Le informazioni di formattazione derivano da
Parse(String) - Impostazioni cultura del thread corrente DateTimeFormatInfo.CurrentInfo (proprietà)
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 del thread corrente DateTimeFormatInfo.CurrentInfo (proprietà)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) Un oggetto CultureInfo Proprietà CultureInfo.DateTimeFormat
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) Implementazione IFormatProvider personalizzata Metodo IFormatProvider.GetFormat

Quando le informazioni di formattazione derivano da DateTimeFormatInfo un oggetto , la proprietà definisce il calendario utilizzato DateTimeFormatInfo.Calendar nell'operazione di analisi.

Se si analizza una stringa di data e ora usando un oggetto con impostazioni personalizzate diverse da quelle delle impostazioni cultura standard, usare il metodo anziché il metodo per migliorare le probabilità di una DateTimeFormatInfo ParseExact Parse conversione corretta. Una stringa di data e ora non standard può essere complessa e difficile da analizzare. Il Parse metodo tenta di analizzare una stringa con diversi modelli di analisi impliciti, che potrebbero avere esito negativo. Al contrario, il metodo richiede di designare in modo esplicito uno o più modelli di analisi esatti ParseExact che potrebbero avere esito positivo. Per altre informazioni, vedere la sezione "DateTimeFormatInfo e Dynamic Data" DateTimeFormatInfo nell'argomento .

Importante

Si noti che le convenzioni di formattazione per determinate impostazioni 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 che rappresenta impostazioni cultura diverse dalle impostazioni cultura invarianti possono avere esito negativo in modo imprevisto se si verifica una delle condizioni IFormatProvider seguenti:

  • I dati specifici delle impostazioni cultura sono stati modificati tra le versioni principali o secondarie del .NET Framework o come risultato di un aggiornamento alla versione esistente del .NET Framework.
  • I dati specifici delle impostazioni cultura riflettono le preferenze dell'utente, che possono variare da computer a computer o da sessione a sessione.
  • I dati specifici delle impostazioni cultura rappresentano impostazioni cultura sostitutive che eseguono l'override delle impostazioni cultura standard o delle impostazioni cultura personalizzate.

Per evitare le difficoltà di analisi dei dati e delle stringhe di ora associate alle modifiche nei dati culturali, è possibile analizzare le stringhe di data e ora usando le impostazioni cultura invarianti oppure è possibile chiamare il metodo o e specificare il formato esatto della stringa da ParseExact TryParseExact analizzare. Se si serializzano e deserializzano dati di data e ora, è possibile usare le convenzioni di formattazione delle impostazioni cultura invarianti oppure è possibile serializzare e deserializzare il valore in formato DateTime binario.

Per altre informazioni, vedere la sezione "Dynamic culture data" nell'argomento e la sezione CultureInfo "Persisting DateTime values" DateTime nell'argomento.

Analisi ed elementi di stile

Tutti gli overload ignorano gli spazi vuoti iniziali, interni o finali nella stringa di Parse input (rappresentata s da nella tabella seguente). La data e l'ora possono essere racchiuse tra parentesi quadre con una coppia di caratteri NUMBER SIGN iniziali e finali ("#", U+0023) e possono essere racchiuse tra uno o più caratteri NULL (U+0000).

Inoltre, Parse(String, IFormatProvider, DateTimeStyles) l'overload ha un styles parametro costituito da uno o più membri dell'enumerazione DateTimeStyles . Questo parametro definisce come deve essere interpretato e come deve essere convertita s l'operazione di analisi in una data e s un'ora. Nella tabella seguente viene descritto l'effetto di ogni DateTimeStyles membro sull'operazione di analisi.

Membro DateTimeStyles Effetto sulla conversione
AdjustToUniversal Analizza s e, se necessario, lo converte in formato UTC, come indicato di seguito:

- Se include una differenza di fuso orario o se non contiene informazioni sul fuso orario ma include il flag , il metodo analizza la stringa, chiama per convertire il valore restituito in UTC e imposta la proprietà s s su styles AssumeLocal ToUniversalTime DateTime Kind DateTimeKind.Utc .
- Se indica che rappresenta l'ora UTC o se non contiene informazioni sul fuso orario ma include il flag , il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore restituito e imposta la proprietà s s su styles AssumeUniversal DateTime Kind 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 può contenere spazi vuoti iniziali, interni s e finali. Comportamento predefinito. Non è possibile eseguire l'override fornendo un valore di enumerazione più DateTimeStyles restrittivo, ad esempio None .
AssumeLocal Specifica che, se s non sono presenti informazioni sul fuso orario, viene presupposta l'ora locale. A meno AdjustToUniversal che non sia presente il flag , la proprietà del valore Kind DateTime restituito viene impostata su DateTimeKind.Local .
AssumeUniversal Specifica che, se s non sono presenti informazioni sul fuso orario, si presuppone l'ora UTC. A meno che non sia presente il flag , il metodo converte il valore restituito dall'ora UTC all'ora locale AdjustToUniversal e imposta la relativa proprietà su DateTime Kind 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 che rappresenta un'ora locale con la DateTime relativa Kind proprietà impostata su DateTimeKind.Local . In genere, tale stringa viene creata chiamando il metodo e usando l'identificatore di formato DateTime.ToString(String) standard "o", "r" o "u".

Valore restituito e DateTime.Kind

Gli DateTime.Parse overload restituiscono un DateTime valore la cui proprietà include informazioni sul fuso Kind orario. Può indicare che l'ora è:

In genere, Parse il metodo restituisce un oggetto la cui proprietà è DateTime Kind DateTimeKind.Unspecified . Tuttavia, il metodo può anche eseguire la conversione del fuso orario e impostare il valore della proprietà in modo diverso, a seconda dei Parse valori dei parametri e Kind s styles :

Se Conversione del fuso orario Proprietà Kind
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 AdjustToUniversal flag . La data e l'ora vengono convertite in Coordinated Universal Time (UTC). DateTimeKind.Utc
s contiene l'indicatore del fuso orario Z o GMT e styles include il RoundtripKind flag . La data e l'ora vengono interpretate come UTC. DateTimeKind.Utc

Nell'esempio seguente vengono convertite stringhe di data che contengono informazioni sul fuso orario nell'ora del 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
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 durante un'operazione di formattazione e analisi Kind usando il DateTimeStyles.RoundtripKind flag . Nell'esempio seguente viene illustrato come il flag influisce sull'operazione di analisi sui valori convertiti in stringhe usando l'identificatore di formato RoundtripKind DateTime "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.
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.

Parse(String)

Converte la rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le convenzioni delle impostazioni cultura del thread corrente.

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 che contiene una data e un'ora da convertire. Per altre informazioni, vedere La stringa da analizzare.

Restituisce

DateTime

Oggetto equivalente alla data e all'ora contenute in s.

Eccezioni

s non contiene una rappresentazione di stringa valida per data e ora.

Esempio

Nell'esempio seguente viene analizzata la rappresentazione di stringa di diversi valori di data e ora in base a :

  • Utilizzo del provider di formato predefinito, che fornisce le convenzioni di formattazione delle impostazioni cultura correnti del thread del computer utilizzato per produrre l'output di esempio. L'output di questo esempio riflette le convenzioni di formattazione delle impostazioni cultura en-US.

  • Utilizzo del valore di stile predefinito, ovvero AllowWhiteSpaces .

Gestisce l'eccezione generata quando il metodo tenta di analizzare la rappresentazione di stringa di una data e di un'ora usando altre convenzioni di formattazione FormatException delle impostazioni cultura. Viene inoltre illustrato come analizzare correttamente un valore di data e ora che non usa le convenzioni di formattazione delle impostazioni cultura del thread corrente.

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.
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 contiene informazioni sul fuso orario, questo metodo restituisce un valore la cui proprietà è e converte la data e s DateTime l'ora in ora Kind DateTimeKind.Local s locale. In caso contrario, non esegue alcuna conversione del fuso orario e restituisce un DateTime valore 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 CurrentCulture proprietà . Per analizzare una stringa usando le convenzioni di formattazione di impostazioni cultura specifiche, chiamare Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles) gli overload .

Questo overload tenta di analizzare s usando DateTimeStyles.AllowWhiteSpaces lo stile.

Vedi anche

Si applica a

Parse(String, IFormatProvider)

Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo DateTime equivalente usando le informazioni sul formato relative alle impostazioni cultura specificate.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
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 che contiene una data e un'ora da convertire. Per altre informazioni, vedere La stringa da analizzare.

provider
IFormatProvider

Oggetto che fornisce informazioni sul formato di s specifiche delle impostazioni cultura. Vedere Analisi e convenzioni delle impostazioni cultura

Restituisce

DateTime

Oggetto equivalente alla data e all'ora contenute in s, come specificato da provider.

Eccezioni

s non contiene una rappresentazione di stringa valida per data e ora.

Esempio

Nell'esempio seguente viene analizzata una matrice di stringhe di data usando le convenzioni delle impostazioni cultura en-US, fr-FR e 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.
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 contiene informazioni sul fuso orario, questo metodo restituisce un valore la cui proprietà è e converte la data e s DateTime l'ora in ora Kind DateTimeKind.Local s locale. In caso contrario, non esegue alcuna conversione del fuso orario e restituisce un DateTime valore la cui proprietà è Kind DateTimeKind.Unspecified .

Questo overload tenta di analizzare s usando lo DateTimeStyles.AllowWhiteSpaces stile .

Vedi anche

Si applica a

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Converte un intervallo di memoria che contiene la rappresentazione stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione.

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>

L'intervallo di memoria che contiene la stringa da analizzare. Per altre informazioni, vedere La stringa da analizzare.

provider
IFormatProvider

Oggetto che fornisce informazioni sul formato di s specifiche delle impostazioni cultura. Vedere Analisi e convenzioni delle impostazioni cultura

styles
DateTimeStyles

Combinazione bit per bit dei valori di enumerazione che indica gli elementi di stile che possono essere presenti in s per la corretta esecuzione dell'operazione di analisi e che definisce come interpretare la data analizzata in relazione al fuso orario o alla data correnti. Un valore tipico da specificare è None.

Restituisce

DateTime

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 per data e ora.

styles contiene una combinazione non valida di valori di DateTimeStyles. Ad esempio, sia AssumeLocal che AssumeUniversal.

Si applica a

Parse(String, IFormatProvider, DateTimeStyles)

Converte la rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando le informazioni sul formato specifiche delle impostazioni cultura e uno stile di formattazione.

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 che contiene una data e un'ora da convertire. Per altre informazioni, vedere La stringa da analizzare.

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a s. Vedere Analisi e convenzioni delle impostazioni cultura

styles
DateTimeStyles

Combinazione bit per bit dei valori di enumerazione che indica gli elementi di stile che possono essere presenti in s per la corretta esecuzione dell'operazione di analisi e che definisce come interpretare la data analizzata in relazione al fuso orario o alla data correnti. Un valore tipico da specificare è None.

Restituisce

DateTime

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 per data e ora.

styles contiene una combinazione non valida di valori di DateTimeStyles. Ad esempio, sia AssumeLocal che AssumeUniversal.

Esempio

Nell'esempio seguente viene Parse(String, IFormatProvider, DateTimeStyles) illustrato il metodo e viene visualizzato il valore della proprietà dei valori Kind 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.
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 overload del metodo converte la data e l'ora in e s imposta la proprietà del valore Kind DateTime restituito nel modo seguente:

Se Conversione del fuso orario Proprietà Kind
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 DateTimeStyles.AdjustToUniversal flag . Per Coordinated Universal Time (UTC) DateTimeKind.Utc
s contiene il designatore del fuso orario Z o GMT e styles include DateTimeStyles.RoundtripKind . Nessuno. DateTimeKind.Utc

Vedi anche

Si applica a