DateTime.Parse DateTime.Parse DateTime.Parse DateTime.Parse Method

Definizione

Converte la rappresentazione di stringa di una data e di un'ora nell'equivalente DateTime.Converts the string representation of a date and time to its DateTime equivalent.

Overload

Parse(String) Parse(String) Parse(String) 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.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Esempi

Esaminare numerosi esempi che chiamano il DateTime.Parse in varie posizioni metodo la osservazioni sezione di questo articolo e nella documentazione per i singoli DateTime.Parse overload.Numerous examples that call the DateTime.Parse method are interspersed throughout the Remarks section of this article and in the documentation for the individual DateTime.Parse overloads.

Nota

Alcuni esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.Some C# examples in this article run in the Try.NET inline code runner and playground. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.Select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Il fuso orario locale dello strumento di esecuzione e playground per codice inline Try.NET è Coordinated Universal Time o ora UTC.The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. Ciò può influire sul comportamento e l'output degli esempi che illustrano i tipi DateTime, DateTimeOffset e TimeZoneInfo e i relativi membri.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

È anche possibile scaricare un set completo di DateTime.Parse esempi, che sono inclusi in un progetto .NET Core 2.0 per Visual c# e un progetto .NET Core 2.0 per Visual Basic, dal dotnet / repository GitHub degli esempi.You can also download a complete set of DateTime.Parse examples, which are included in a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Commenti

Contenuto della sezione:In this section:

Quale metodo viene chiamato?Which method do I call?

ATo CallCall
Analizzare una stringa di data e ora usando le convenzioni delle impostazioni cultura correnti.Parse a date and time string by using the conventions of the current culture. Overload Parse(String)Parse(String) overload
Analizzare una stringa di data e ora usando le convenzioni delle impostazioni cultura specifiche.Parse a date and time string by using the conventions of a specific culture. Parse(String, IFormatProvider) eseguire l'overload (vedere analisi e le convenzioni culturali)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analizzare una stringa di data e ora con elementi di stile di visualizzazione speciali (ad esempio spazi vuoti o senza spazi).Parse a date and time string with special style elements (such as white space or no white space). Overload Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Analizzare una stringa di data e ora che deve essere in un formato particolare.Parse a date and time string that must be in a particular format. DateTime.ParseExact o DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Analizzare una stringa di data e ora ed eseguire una conversione in ora UTC o locale.Parse a date and time string and perform a conversion to UTC or local time. Overload Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Analizzare una stringa di data e ora senza la gestione delle eccezioni.Parse a date and time string without handling exceptions. Metodo DateTime.TryParseDateTime.TryParse method
Ripristinare (roundtrip) un valore di data e ora creato da un'operazione di formattazione.Restore (round-trip) a date and time value created by a formatting operation. Passare la stringa di formato standard "o" o "r" per il ToString(String) metodo e chiamare il Parse(String, IFormatProvider, DateTimeStyles) overload con DateTimeStyles.RoundtripKindPass the "o" or "r" standard format string to the ToString(String) method, and call the Parse(String, IFormatProvider, DateTimeStyles) overload with DateTimeStyles.RoundtripKind
Analizzare una stringa di data e ora in un formato fisso attraverso i limiti di computer (e possibilmente relative alla lingua).Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. DateTime.ParseExact o DateTime.TryParseExact (metodo)DateTime.ParseExact or DateTime.TryParseExact method

La stringa da analizzareThe string to parse

Il Parse metodo prova a convertire la rappresentazione di stringa di un valore di data e ora al relativo DateTime equivalente.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Tenta di analizzare la stringa di input completamente senza generare un FormatException eccezione.It tries to parse the input string completely without throwing a FormatException exception.

Importante

Se l'operazione di analisi ha esito negativo a causa di un formato stringa non riconosciuto, il Parse metodo genera un FormatException, mentre le TryParse restituzione del metodo false.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. Poiché la gestione delle eccezioni può essere costosa, è consigliabile usare Parse quando è previsto l'operazione di analisi abbia esito positivo perché l'origine di input è attendibile.Because exception handling can be expensive, you should use Parse when the parsing operation is expected to succeed because the input source is trusted. TryParse è preferibile quando sono probabile che gli errori di analisi, soprattutto perché un'origine di input non attendibile o si hanno valori predefiniti ragionevoli per sostituire le stringhe che non vengono analizzate correttamente.TryParse is preferable when parsing failures are likely, particularly because an input source is not trusted, or you have reasonable default values to substitute for strings that do not parse successfully.

La stringa da analizzare è possibile usare uno dei formati seguenti:The string to be parsed can take any of the following forms:

  • Una stringa con una data e ora.A string with a date and a time component.

  • Una stringa con una data ma non all'ora.A string with a date but no time component. Se il componente della fase non è presente, il metodo presuppone ore 00.00.If the time component is absent, the method assumes 12:00 midnight. Se il componente Data dispone di un anno a due cifre, viene convertito in un anno in base il Calendar.TwoDigitYearMax del calendario corrente di cultura correnti o della cultura specificata corrente (se si usa un overload con un valore non null provider argomento).If the date component has a two-digit year, it is converted to a year based on the Calendar.TwoDigitYearMax of the current culture's current calendar or the specified culture's current calendar (if you use an overload with a non-null provider argument).

  • Una stringa con un componente di data che include solo il mese e anno, ma nessun componente giorno.A string with a date component that includes only the month and the year but no day component. Il metodo presuppone che il primo giorno del mese.The method assumes the first day of the month.

  • Una stringa con un componente di data che include solo il mese e giorno, ma nessun componente anno.A string with a date component that includes only the month and the day but no year component. Il metodo presuppone che l'anno corrente.The method assumes the current year.

  • Una stringa con un'ora ma nessun componente di Data.A string with a time but no date component. Il metodo presuppone che la data corrente a meno che non si chiama il Parse(String, IFormatProvider, DateTimeStyles) rapporto di overload e includere DateTimeStyles.NoCurrentDateDefault nel styles argomento, nel quale caso il metodo presuppone che una data del 1 ° gennaio 0001.The method assumes the current date unless you call the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Una stringa con un componente di ora che include solo l'ora e un indicatore AM/PM, con nessun componente di Data.A string with a time component that includes only the hour and an AM/PM designator, with no date component. Il metodo presuppone la data corrente e un'ora senza alcun minuti e senza secondi.The method assumes the current date and a time with no minutes and no seconds. È possibile modificare questo comportamento chiamando il Parse(String, IFormatProvider, DateTimeStyles) rapporto di overload e includere DateTimeStyles.NoCurrentDateDefault nel styles argomento, nel quale caso il metodo presuppone che una data del 1 ° gennaio 0001.You can change this behavior by calling the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Stringa che include informazioni sul fuso orario ed è conforme a ISO 8601.A string that includes time zone information and conforms to ISO 8601. Negli esempi seguenti, la prima stringa designa Coordinated Universal Time (UTC) e il secondo definisce il tempo in un fuso orario è sette ore precedenti rispetto all'ora UTC:In the following examples, the first string designates Coordinated Universal Time (UTC), and the second designates the time in a time zone that's seven hours earlier than UTC:

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

  • Una stringa che include l'indicatore GMT ed è conforme al formato di ora RFC 1123; Per esempio:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    "Sabato 01 novembre 2008 19 35: 12:00:00 GMT""Sat, 01 Nov 2008 19:35:00 GMT"

  • Una stringa che include la data e ora insieme a informazioni relative alla differenza fuso orario; Per esempio:A string that includes the date and time along with time zone offset information; for example:

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

Nell'esempio seguente analizza le stringhe in ognuno di questi formati utilizzando le convenzioni di formattazione delle impostazioni cultura correnti, ovvero in questo caso le impostazioni cultura en-US:The following example parses strings in each of these formats by using the formatting conventions of the current culture, which in this case is the en-US culture:

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 il calendario usato per il metodo di analisi (vedere convenzioni relative alla lingua e analisi), il Parse metodo analizza la stringa correttamente.If the input string represents a leap day in a leap year in the calendar used by the parsing method (see Parsing and cultural conventions), the Parse method parses the string successfully. Se la stringa di input rappresenta un giorno intercalare in un non-anno bisestile, il metodo genera un FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Poiché il Parse metodo tenta di analizzare la rappresentazione di stringa di una data e ora usando le regole di formattazione delle impostazioni cultura specificate, il tentativo di analizzare una stringa tra diverse impostazioni cultura corrente può avere esito negativo.Because the Parse method tries to parse the string representation of a date and time by using the formatting rules of the current or a specified culture, trying to parse a string across different cultures can fail. Per analizzare una data specifica e formato di ora tra impostazioni locali diverse, usare uno degli overload del DateTime.ParseExact metodo e fornire un identificatore di formato.To parse a specific date and time format across different locales, use one of the overloads of the DateTime.ParseExact method and provide a format specifier.

Convenzioni culturale e analisiParsing and cultural conventions

Tutti gli overload del Parse metodo sono dipendenti dalle impostazioni cultura, a meno che la stringa da analizzare (rappresentata dal s nella tabella seguente) conforme al modello di ISO 8601.All overloads of the Parse method are culture-sensitive unless the string to be parsed (which is represented by s in the following table) conforms to the ISO 8601 pattern. L'operazione di analisi Usa le informazioni di formattazione in un DateTimeFormatInfo oggetto derivato come indicato di seguito:The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

Importante

Le ere nel calendario giapponese sono basate sul regno dell'imperatore e pertanto è previsto che cambino.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. Ad esempio, il 1° maggio 2019 contraddistingue l'inizio dell'era Reiwa in JapaneseCalendar e JapaneseLunisolarCalendar.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. Questo cambio di era interessa tutte le applicazioni che usano questi calendari.Such a change of era affects all applications that use these calendars. Vedere Handling a new era in the Japanese calendar in .NET (Gestione di una nuova era nel calendario giapponese in .NET) per altre informazioni e per determinare se le proprie applicazioni sono interessate dal cambio.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Vedere Prepare your application for the Japanese era change (Preparare l'applicazione per il cambio di era giapponese) per informazioni sul test delle applicazioni nei sistemi Windows per verificare che siano pronte per il cambio di era.See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change. Vedere Utilizzo delle ere per informazioni sulle funzionalità in .NET che supportano calendari con più ere e per le procedure consigliate per l'uso dei calendari che supportano più ere.See Working with eras for features in .NET that support calendars with multiple eras and for best practices when working with calendars that support multiple eras.

Se si chiamaIf you call E provider èAnd provider is Informazioni di formattazione sono derivate daFormatting information is derived from
Parse(String) - Impostazioni cultura del thread corrente (DateTimeFormatInfo.CurrentInfo proprietà)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Oggetto DateTimeFormatInfo oggettoa DateTimeFormatInfo object L'oggetto specificato DateTimeFormatInfo oggettoThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null Impostazioni cultura del thread corrente (DateTimeFormatInfo.CurrentInfo proprietà)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Oggetto CultureInfo oggettoa CultureInfo object Proprietà CultureInfo.DateTimeFormatThe CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Custom IFormatProvider implementazioneCustom IFormatProvider implementation Metodo IFormatProvider.GetFormat The IFormatProvider.GetFormat method

Quando le informazioni di formattazione sono derivata da un DateTimeFormatInfo oggetti, il DateTimeFormatInfo.Calendar proprietà definisce il calendario utilizzato nell'operazione di analisi.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

Se si utilizza una stringa di data e ora usando una DateTimeFormatInfo oggetto con le impostazioni che sono diverse da quelle delle impostazioni cultura standard personalizzate, usare il ParseExact invece del metodo di Parse metodo per aumentare le probabilità per una corretta conversione.If you parse a date and time string by using a DateTimeFormatInfo object with customized settings that are different from those of a standard culture, use the ParseExact method instead of the Parse method to improve the chances for a successful conversion. Una stringa di ora e data non standard può essere complessa e difficile da analizzare.A non-standard date and time string can be complicated and difficult to parse. Il Parse metodo tenta di analizzare una stringa con diversi modelli di analisi impliciti, ognuno dei quali potrebbero non riuscire.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Al contrario, il ParseExact metodo richiede all'utente di impostare in modo esplicito uno o più modelli di analisi che sono probabile che abbia esito positivo.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Per altre informazioni, vedere la sezione "DateTimeFormatInfo e Dynamic Data" nel DateTimeFormatInfo argomento.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

Importante

Si noti che le convenzioni di formattazione per determinate impostazioni cultura sono dinamiche e possono essere soggette a modifiche.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. Ciò significa che le operazioni di analisi che dipendono dalle convenzioni di formattazione delle impostazioni cultura predefinite (corrente) o che specificano un IFormatProvider oggetto che rappresenta le impostazioni cultura diverse da impostazioni cultura invarianti imprevista può avere esito negativo se si verifica una delle operazioni seguenti:This means that parsing operations that depend on the formatting conventions of the default (current) culture or that specify an IFormatProvider object that represents a culture other than the invariant culture can unexpectedly fail if any of the following occurs:

  • I dati specifici delle impostazioni cultura sono stato modificato tra versioni principali o secondari di .NET Framework o come risultato di un aggiornamento alla versione esistente di .NET Framework.The culture-specific data has changed between major or minor versions of the .NET Framework or as the result of an update to the existing version of the .NET Framework.
  • I dati specifici delle impostazioni cultura riflettano preferenze dell'utente, che possono variare da computer a computer o una sessione da altra.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • I dati specifici delle impostazioni cultura rappresentano impostazioni cultura di sostituzione che sostituisce le impostazioni delle impostazioni cultura standard o impostazioni cultura personalizzate.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Per evitare le difficoltà nell'analisi di stringhe di data e ora che sono associate alle modifiche nei dati relative alla lingua, è possibile analizzare le stringhe di data e ora con le impostazioni cultura invarianti, oppure è possibile chiamare il ParseExact o TryParseExact (metodo) e specificare il formato esatto della stringa da analizzare.To prevent the difficulties in parsing data and time strings that are associated with changes in cultural data, you can parse date and time strings by using the invariant culture, or you can call the ParseExact or TryParseExact method and specify the exact format of the string to be parsed. Se si serializza e deserializza i dati di data e ora, è possibile usare le convenzioni di formattazione della cultura invariabile oppure è possibile serializzare e deserializzare il DateTime valore in un formato binario.If you are serializing and deserializing date and time data, you can either use the formatting conventions of the invariant culture, or you can serialize and deserialize the DateTime value in a binary format.

Per altre informazioni, vedere la sezione "dati dinamici delle impostazioni cultura" i CultureInfo argomento e i valori di data/ora persistenti"" sezione di DateTime argomento.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Elementi di stile e l'analisiParsing and style elements

Tutti i Parse overload ignorare i caratteri spazi vuoti iniziali, interni o finali nella stringa di input (rappresentata dal s nella tabella seguente).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). Data e ora possono essere racchiusi tra parentesi quadre con una coppia di caratteri cancelletto ("#", U + 0023) iniziali e finali e possono essere seguite da uno o più caratteri NULL (u+0000).The date and time can be bracketed with a pair of leading and trailing NUMBER SIGN characters ("#", U+0023), and can be trailed with one or more NULL characters (U+0000).

Inoltre, il Parse(String, IFormatProvider, DateTimeStyles) overload presenta una styles parametro costituito da uno o più membri del DateTimeStyles enumerazione.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. Questo parametro definisce la modalità s deve essere interpretato e modo in cui convertire l'operazione di analisi s a una data e ora.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. Nella tabella seguente vengono descritti gli effetti della ognuno DateTimeStyles membro sull'operazione di analisi.The following table describes the effect of each DateTimeStyles member on the parse operation.

Membro DateTimeStylesDateTimeStyles member Effetto sulla conversioneEffect on conversion
AdjustToUniversal Analizza s e, se necessario, lo converte in formato UTC, come indicato di seguito:Parses s and, if necessary, converts it to UTC, as follows:

-Se s include una differenza di fuso orario, oppure se s non contiene alcuna informazione di fuso orario, ma styles include il AssumeLocal flag, il metodo analizza la stringa, le chiamate ToUniversalTime convertire l'oggetto restituito DateTime valore Ora UTC e imposta il Kind proprietà DateTimeKind.Utc.- If s includes a time zone offset, or if s contains no time zone information but styles includes the AssumeLocal flag, the method parses the string, calls ToUniversalTime to convert the returned DateTime value to UTC, and sets the Kind property to DateTimeKind.Utc.
-Se s rappresenta il formato UTC, oppure se s non contiene informazioni sul fuso orario, ma styles include il AssumeUniversal flag, il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sull'oggetto restituito DateTime valore e imposta il Kind proprietà DateTimeKind.Utc.- If s indicates that it represents UTC, or if s does not contain time zone information but styles includes the AssumeUniversal flag, the method parses the string, performs no time zone conversion on the returned DateTime value, and sets the Kind property to DateTimeKind.Utc.
-In tutti gli altri casi, il flag non ha alcun effetto.- In all other cases, the flag has no effect.
AllowInnerWhite Questo valore viene ignorato.This value is ignored. Lo spazio vuoto interno è sempre consentito negli elementi di data e ora di s.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Questo valore viene ignorato.This value is ignored. Lo spazio vuoto iniziale è sempre consentito negli elementi di data e ora di s.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite Questo valore viene ignorato.This value is ignored. Lo spazio vuoto finale è sempre consentito negli elementi di data e ora di s.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Specifica che s può contenere iniziali, interni e gli spazi vuoti finali.Specifies that s may contain leading, inner, and trailing white spaces. Comportamento predefinito.This is the default behavior. Impossibile eseguire l'override fornendo una più restrittiva DateTimeStyles valore dell'enumerazione, ad esempio None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Specifica che se s mancano si presuppone che le informazioni sul fuso orario, ora locale.Specifies that if s lacks any time zone information, local time is assumed. A meno che il AdjustToUniversal flag è presente, il Kind proprietà del valore restituito DateTime è impostato su DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Specifica che se s mancano presuppone alcuna informazione sul fuso orario UTC.Specifies that if s lacks any time zone information, UTC is assumed. A meno che il AdjustToUniversal flag è presente, il metodo converte l'oggetto restituito DateTime valore rispetto all'ora UTC in ora locale e imposta relativo Kind proprietà DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the method converts the returned DateTime value from UTC to local time and sets its Kind property to DateTimeKind.Local.
None Anche se valido, questo valore viene ignorato.Although valid, this value is ignored.
RoundtripKind Per le stringhe che contengono informazioni sul fuso orario, prova a impedire la conversione di una stringa di data e ora in un DateTime valore che rappresenta un'ora locale con relativa Kind impostata su DateTimeKind.Local.For strings that contain time zone information, tries to prevent the conversion of a date and time string to a DateTime value that represents a local time with its Kind property set to DateTimeKind.Local. In genere, tale stringa viene creato chiamando il DateTime.ToString(String) (metodo) e con l'identificatore di formato standard "o", "r" o "u".Typically, such a string is created by calling the DateTime.ToString(String) method and by using the "o", "r", or "u" standard format specifier.

Il valore restituito e DateTime. KindThe return value and DateTime.Kind

Il DateTime.Parse overload restituiscono una DateTime valore la cui proprietà Kind proprietà include informazioni sul fuso orario.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Può indicare che l'ora è:It can indicate that the time is:

In generale, il Parse metodo restituisce un DateTime oggetto la cui proprietà Kind è di proprietà DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Tuttavia, il Parse metodo può anche eseguire una conversione del fuso orario e impostare il valore della Kind proprietà in modo diverso, a seconda dei valori del s e styles parametri:However, the Parse method may also perform time zone conversion and set the value of the Kind property differently, depending on the values of the s and styles parameters:

SeIf Conversione del fuso orarioTime zone conversion Proprietà KindKind property
s contiene informazioni sul fuso orario.s contains time zone information. Data e ora viene convertito nell'ora nel fuso orario locale.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s contiene informazioni sul fuso orario, e styles include il AdjustToUniversal flag.s contains time zone information, and styles includes the AdjustToUniversal flag. Data e ora viene convertito a Coordinated Universal Time (UTC).The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s contiene l'identificatore del fuso orario Z o GMT, e styles include il RoundtripKind flag.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. Data e ora vengono interpretati come ora UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

L'esempio seguente converte le stringhe di data che contengono informazioni sul fuso orario all'ora nel fuso orario locale:The following example converts date strings that contain time zone information to the time in the local time zone:

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                                             

È inoltre possibile mantenere il valore di data e dell'ora Kind proprietà durante una formattazione e l'operazione di analisi usando il DateTimeStyles.RoundtripKind flag.You can also preserve the value of a date and time's Kind property during a formatting and parsing operation by using the DateTimeStyles.RoundtripKind flag. Nell'esempio seguente viene illustrato come la RoundtripKind flag influisce sull'operazione di analisi su DateTime valori che vengono convertiti in stringhe usando l'identificatore di formato "o", "r" o "u".The following example illustrates how the RoundtripKind flag affects the parsing operation on DateTime values that are converted to strings by using the "o", "r", or "u" format specifier.

   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) Parse(String) Parse(String) 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.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

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 String String String

Stringa che contiene una data e un'ora da convertire.A string that contains a date and time to convert. Per altre informazioni, vedere La stringa da analizzare.See The string to parse for more information.

Restituisce

Oggetto equivalente alla data e all'ora contenute in s.An object that is equivalent to the date and time contained in s.

Eccezioni

s non contiene una rappresentazione di stringa valida per data e ora.s does not contain a valid string representation of a date and time.

Commenti

Se s contiene informazioni sul fuso orario, il metodo restituisce un DateTime valore la cui proprietà Kind è di proprietà DateTimeKind.Local e converte la data e ora in s nell'ora locale.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. In caso contrario, non eseguita alcuna conversione del fuso orario e restituisce un DateTime valore la cui proprietà Kind è di proprietà DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Questo overload tenta di analizzare s usando le convenzioni di formattazione delle impostazioni cultura correnti.This overload attempts to parse s by using the formatting conventions of the current culture. Le impostazioni cultura correnti è indicata dal CurrentCulture proprietà.The current culture is indicated by the CurrentCulture property. Per analizzare una stringa usando le convenzioni di formattazione delle impostazioni cultura specifiche, chiamare il Parse(String, IFormatProvider) o il Parse(String, IFormatProvider, DateTimeStyles) overload.To parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

Questo overload tenta di analizzare s tramite DateTimeStyles.AllowWhiteSpaces stile.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

EsempioExample

Nell'esempio seguente consente di analizzare la rappresentazione di stringa dei valori di data e ora diversi da:The following example parses the string representation of several date and time values by:

  • Usa il provider di formato predefinito, che fornisce le convenzioni di formattazione delle impostazioni cultura del thread corrente del computer utilizzato per produrre l'output di esempio.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. L'output di questo esempio riflette le convenzioni di formattazione delle impostazioni cultura en-US.The output from this example reflects the formatting conventions of the en-US culture.

  • Utilizzando il valore di stile predefinito, ovvero AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Gestisce il FormatException convenzioni di formattazione di eccezione generata quando il metodo tenta di analizzare la rappresentazione di stringa di data e ora usando alcune delle impostazioni cultura.It handles the FormatException exception that is thrown when the method tries to parse the string representation of a date and time by using some other culture's formatting conventions. 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.It also shows how to successfully parse a date and time value that does not use the formatting conventions of the current thread culture.

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.
Vedi anche

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

public:
 static DateTime Parse(System::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 String String String

Stringa che contiene una data e un'ora da convertire.A string that contains a date and time to convert. Per altre informazioni, vedere La stringa da analizzare.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni sul formato di s specifiche delle impostazioni cultura.An object that supplies culture-specific format information about s. Vedere Analisi e convenzioni delle impostazioni culturaSee Parsing and cultural conventions

Restituisce

Oggetto equivalente alla data e all'ora contenute in s, come specificato da provider.An object that is equivalent to the date and time contained in s as specified by provider.

Eccezioni

s non contiene una rappresentazione di stringa valida per data e ora.s does not contain a valid string representation of a date and time.

Commenti

Se s contiene informazioni sul fuso orario, il metodo restituisce un DateTime valore la cui proprietà Kind è di proprietà DateTimeKind.Local e converte la data e ora in s nell'ora locale.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. In caso contrario, non eseguita alcuna conversione del fuso orario e restituisce un DateTime valore la cui proprietà Kind è di proprietà DateTimeKind.Unspecified.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Questo overload tenta di analizzare s utilizzando il DateTimeStyles.AllowWhiteSpaces stile.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

EsempioExample

Nell'esempio seguente analizza una matrice di stringhe di data usando le convenzioni di impostazioni cultura de-DE, en-US, fr-FR.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Viene illustrato che le rappresentazioni di stringa di una singola data possono essere interpretate in modo diverso nelle diverse impostazioni cultura.It demonstrates that the string representations of a single date can be interpreted differently across different cultures.

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.
Vedi anche

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = null, 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 = null, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametri

s
ReadOnlySpan<Char>

L'intervallo di memoria che contiene la stringa da analizzare.The memory span that contains the string to parse. Per altre informazioni, vedere La stringa da analizzare.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni sul formato di s specifiche delle impostazioni cultura.An object that supplies culture-specific format information about s. Vedere Analisi e convenzioni delle impostazioni culturaSee Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles 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.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Un valore tipico da specificare è None.A typical value to specify is None.

Restituisce

Oggetto equivalente alla data e all'ora contenute in s, come specificato da provider e styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Eccezioni

s non contiene una rappresentazione di stringa valida per data e ora.s does not contain a valid string representation of a date and time.

styles contiene una combinazione non valida di valori di DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Ad esempio, sia AssumeLocal che AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

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);
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 String String String

Stringa che contiene una data e un'ora da convertire.A string that contains a date and time to convert. Per altre informazioni, vedere La stringa da analizzare.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a s.An object that supplies culture-specific formatting information about s. Vedere Analisi e convenzioni delle impostazioni culturaSee Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles 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.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Un valore tipico da specificare è None.A typical value to specify is None.

Restituisce

Oggetto equivalente alla data e all'ora contenute in s, come specificato da provider e styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Eccezioni

s non contiene una rappresentazione di stringa valida per data e ora.s does not contain a valid string representation of a date and time.

styles contiene una combinazione non valida di valori di DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Ad esempio, sia AssumeLocal che AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Commenti

Questo overload del metodo converte la data e ora s e imposta la Kind proprietà dell'oggetto restituito DateTime valore come indicato di seguito:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

SeIf Conversione del fuso orarioTime zone conversion Proprietà KindKind property
s non contiene alcuna informazione di fuso orario.s contains no time zone information. Nessuno.None. DateTimeKind.Unspecified
s contiene informazioni sul fuso orario.s contains time zone information. Per l'ora nel fuso orario localeTo the time in the local time zone DateTimeKind.Local
s contiene informazioni sul fuso orario, e ' include gli stili di DateTimeStyles.AdjustToUniversal flag.s contains time zone information, and `styles includes the DateTimeStyles.AdjustToUniversal flag. In Coordinated Universal Time (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s contiene l'identificatore del fuso orario Z o GMT, e styles include il DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. Nessuno.None. Utc

EsempioExample

Nell'esempio seguente viene illustrato il Parse(String, IFormatProvider, DateTimeStyles) metodo e visualizza il valore della Kind proprietà dell'oggetto risultante DateTime valori.The following example demonstrates the Parse(String, IFormatProvider, DateTimeStyles) method and displays the value of the Kind property of the resulting DateTime values.

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.
Vedi anche

Si applica a