DateTime.Parse Metodo

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)

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)

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)

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)

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

Molti esempi che chiamano il metodo DateTime.Parse sono sparpagliati nella sezione osservazioni di questo articolo e nella documentazione per i singoli overload DateTime.Parse.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 esempi DateTime.Parse, inclusi in un progetto .NET Core 2,0 per C# e un progetto .NET Core 2,0 per Visual Basic, dal repository GitHub DotNet/Samples.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 di impostazioni cultura specifiche.Parse a date and time string by using the conventions of a specific culture. Overload Parse(String, IFormatProvider) (vedere analisi e convenzioni culturali)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analizzare una stringa di data e ora con elementi di stile speciali, ad esempio spazi vuoti o spazi vuoti.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 gestire le eccezioni.Parse a date and time string without handling exceptions. Metodo DateTime.TryParseDateTime.TryParse method
Restore (round trip) 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" al metodo ToString(String) e chiamare l'overload Parse(String, IFormatProvider, DateTimeStyles) 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 tra i limiti del computer e possibilmente quelli culturali.Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. Metodo DateTime.ParseExact o DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact method

Stringa da analizzareThe string to parse

Il metodo Parse tenta di convertire la rappresentazione di stringa di un valore di data e ora nell'equivalente DateTime.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Tenta di analizzare completamente la stringa di input senza generare un'eccezione FormatException.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 metodo Parse genera una FormatException, mentre il metodo TryParse restituisce 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 utilizzare Parse quando l'operazione di analisi ha 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 è probabile che si verifichino errori di analisi, in particolare perché un'origine di input non è attendibile o se si dispone di 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 può assumere uno dei seguenti formati:The string to be parsed can take any of the following forms:

  • Stringa con un componente data e ora.A string with a date and a time component.

  • Stringa con una data ma non un componente ora.A string with a date but no time component. Se il componente ora è assente, il metodo presuppone 12:00 mezzanotte.If the time component is absent, the method assumes 12:00 midnight. Se il componente relativo alla data ha un anno a due cifre, viene convertito in un anno basato sul valore Calendar.TwoDigitYearMax del calendario corrente delle impostazioni cultura correnti o del calendario corrente delle impostazioni cultura specificate (se si usa un overload con un argomento non null provider).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).

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

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

  • Stringa con un componente di data e ora ma senza data.A string with a time but no date component. Il metodo presuppone la data corrente a meno che non si chiami l'overload Parse(String, IFormatProvider, DateTimeStyles) e includa DateTimeStyles.NoCurrentDateDefault nell'argomento styles, nel qual caso il metodo presuppone una data del 1 ° gennaio 0001.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.

  • Stringa con un componente ora che include solo l'ora e un indicatore AM/PM, senza componente 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 l'ora senza minuti e nessun secondo.The method assumes the current date and a time with no minutes and no seconds. È possibile modificare questo comportamento chiamando l'overload Parse(String, IFormatProvider, DateTimeStyles) e includere DateTimeStyles.NoCurrentDateDefault nell'argomento styles, nel qual caso il metodo presuppone una data del 1 ° gennaio 0001.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 e conforme allo standard ISO 8601.A string that includes time zone information and conforms to ISO 8601. Negli esempi seguenti, la prima stringa designa l'ora UTC (Coordinated Universal Time) e la seconda indica l'ora in un fuso orario che è sette ore prima dell'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.0000000 Z""2008-11-01T19:35:00.0000000Z"
    "2008-11-01T19:35:00.0000000-07:00""2008-11-01T19:35:00.0000000-07:00"

  • Stringa che include l'indicatore GMT e conforme al formato dell'ora RFC 1123; Per esempio:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    "Sat, 01 nov 2008 19:35:00 GMT""Sat, 01 Nov 2008 19:35:00 GMT"

  • Stringa che include la data e l'ora insieme alle informazioni di offset del 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 vengono analizzate le stringhe in ognuno di questi formati usando le convenzioni di formattazione delle impostazioni cultura correnti, che in questo caso sono le impostazioni cultura en-US: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 nel calendario usato dal metodo di analisi (vedere analisi e convenzioni culturali), il metodo Parse analizza correttamente la stringa.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 anno non bisestile, il metodo genera un'eccezione FormatException.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Poiché il metodo Parse 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 in impostazioni cultura diverse 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 un formato di data e ora specifico tra impostazioni locali diverse, usare uno degli overload del metodo DateTime.ParseExact 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.

Analisi e convenzioni culturaliParsing and cultural conventions

Tutti gli overload del metodo Parse sono dipendenti dalle impostazioni cultura, a meno che la stringa da analizzare, rappresentata da s nella tabella seguente, sia conforme allo schema 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 oggetto DateTimeFormatInfo derivato come segue: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 Le informazioni di formattazione sono derivate daFormatting information is derived from
Parse(String) - Impostazioni cultura del thread corrente (proprietà DateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) oggetto DateTimeFormatInfoa DateTimeFormatInfo object Oggetto DateTimeFormatInfo specificatoThe 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 (proprietà DateTimeFormatInfo.CurrentInfo)The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) oggetto CultureInfoa CultureInfo object Proprietà CultureInfo.DateTimeFormatThe CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Implementazione IFormatProvider personalizzataCustom IFormatProvider implementation Metodo IFormatProvider.GetFormatThe IFormatProvider.GetFormat method

Quando le informazioni di formattazione sono derivate da un oggetto DateTimeFormatInfo, la proprietà DateTimeFormatInfo.Calendar 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 analizza una stringa di data e ora usando un oggetto DateTimeFormatInfo con impostazioni personalizzate diverse da quelle delle impostazioni cultura standard, usare il metodo ParseExact anziché il metodo Parse per migliorare le probabilità di una conversione corretta.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 data e ora non standard può essere complessa e difficile da analizzare.A non-standard date and time string can be complicated and difficult to parse. Il metodo Parse tenta di analizzare una stringa con diversi modelli di analisi implicita, che potrebbero avere esito negativo.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Al contrario, per il metodo ParseExact è necessario definire in modo esplicito uno o più modelli di analisi esatti che potrebbero avere esito positivo.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Per ulteriori informazioni, vedere la sezione "DateTimeFormatInfo and Dynamic Data" nell'argomento DateTimeFormatInfo.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 (correnti) o che specificano un oggetto IFormatProvider che rappresenta le impostazioni cultura diverse dalla lingua inglese possono non riuscire in modo imprevisto se si verifica una delle condizioni 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 stati modificati tra le versioni principali o secondarie del .NET Framework o il risultato di un aggiornamento della versione esistente del .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 riflettono le preferenze dell'utente, che possono variare da computer a computer o da sessione a sessione.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 le impostazioni cultura di sostituzione che eseguono l'override delle impostazioni cultura standard o 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 delle stringhe di data e ora associate a modifiche nei dati culturali, è possibile analizzare le stringhe di data e ora usando la lingua inglese oppure è possibile chiamare il metodo ParseExact o TryParseExact 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 esegue la serializzazione e la deserializzazione dei dati di data e ora, è possibile usare le convenzioni di formattazione delle impostazioni cultura invarianti oppure è possibile serializzare e deserializzare il valore DateTime 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 ulteriori informazioni, vedere la sezione relativa ai dati relativi alle impostazioni cultura dinamiche nell'argomento CultureInfo e la sezione "valori DateTime di salvataggio permanente" nell'argomento DateTime.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 analisi e stileParsing and style elements

Tutti gli overload Parse ignorano gli spazi vuoti iniziali, interni o finali nella stringa di input, rappresentata da 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). La data e l'ora possono essere racchiuse tra parentesi quadre con una coppia di caratteri di CANCELLetto iniziali e finali ("#", U + 0023) e possono essere finali con 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, l'overload Parse(String, IFormatProvider, DateTimeStyles) ha un parametro styles costituito da uno o più membri dell'enumerazione DateTimeStyles.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 il modo in cui deve essere interpretato s e il modo in cui l'operazione di analisi deve convertire s in 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 viene descritto l'effetto di ogni membro DateTimeStyles nell'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 o se s non contiene informazioni sul fuso orario ma styles include il flag AssumeLocal, il metodo analizza la stringa, chiama ToUniversalTime per convertire il valore DateTime restituito in UTC e imposta la proprietà Kind su DateTimeKind.Utc.- 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 indica che rappresenta l'ora UTC o se s non contiene informazioni sul fuso orario ma styles include il flag AssumeUniversal, il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore DateTime restituito e imposta il Kind da @no__t a 6.- 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. Gli spazi vuoti interni sono sempre consentiti 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. Gli spazi vuoti iniziali sono sempre consentiti 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. Gli spazi vuoti finali sono sempre consentiti 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 spazi vuoti iniziali, interni e finali.Specifies that s may contain leading, inner, and trailing white spaces. Comportamento predefinito.This is the default behavior. Non è possibile eseguirne l'override fornendo un valore di enumerazione DateTimeStyles più restrittivo, ad esempio None.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Specifica che se s non dispone di informazioni sul fuso orario, si presuppone l'ora locale.Specifies that if s lacks any time zone information, local time is assumed. A meno che non sia presente il flag AdjustToUniversal, la proprietà Kind del valore restituito DateTime è impostata 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 non dispone di informazioni sul fuso orario, si presuppone l'ora UTC.Specifies that if s lacks any time zone information, UTC is assumed. A meno che non sia presente il flag AdjustToUniversal, il metodo converte il valore DateTime restituito dall'ora UTC all'ora locale e imposta la relativa proprietà Kind su 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 Sebbene valido, questo valore viene ignorato.Although valid, this value is ignored.
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 DateTime che rappresenta un'ora locale con la relativa proprietà 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, una stringa di questo tipo viene creata chiamando il metodo DateTime.ToString(String) e usando 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

Gli overload DateTime.Parse restituiscono un valore DateTime la cui proprietà Kind include le 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 genere, il metodo Parse restituisce un oggetto DateTime la cui proprietà Kind è DateTimeKind.Unspecified.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. Tuttavia, il metodo Parse può anche eseguire la conversione del fuso orario e impostare il valore della proprietà Kind in modo diverso, a seconda dei valori dei parametri s e styles: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 Kind (proprietà)Kind property
s contiene le informazioni sul fuso orario.s contains time zone information. La data e l'ora vengono convertite nell'ora del fuso orario locale.The date and time is converted to the time in the local time zone. DateTimeKind.Local
s contiene le informazioni sul fuso orario e styles include il flag AdjustToUniversal.s contains time zone information, and styles includes the AdjustToUniversal flag. La data e l'ora vengono convertite in UTC (Coordinated Universal Time).The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
s contiene la designazione del fuso orario Z o GMT e styles include il flag RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. La data e l'ora vengono interpretate come UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

Nell'esempio seguente vengono convertite le stringhe di data contenenti informazioni sul fuso orario nell'ora del 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                                             

È anche possibile mantenere il valore di una proprietà Kind di data e ora durante un'operazione di formattazione e analisi usando il flag DateTimeStyles.RoundtripKind.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 il modo in cui il flag RoundtripKind influiscono sull'operazione di analisi sui valori DateTime 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)

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

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 è null.s is null.

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, questo metodo restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Local e converte la data e l'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 viene eseguita alcuna conversione del fuso orario e viene restituito un valore DateTime la cui proprietà Kind è 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 sono indicate dalla proprietà CurrentCulture.The current culture is indicated by the CurrentCulture property. Per analizzare una stringa usando le convenzioni di formattazione di impostazioni cultura specifiche, chiamare gli overload Parse(String, IFormatProvider) o Parse(String, IFormatProvider, DateTimeStyles).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 usando lo stile DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

EsempioExample

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

  • Utilizzando 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, che è AllowWhiteSpaces.Using the default style value, which is AllowWhiteSpaces.

Gestisce l'eccezione FormatException generata quando il metodo tenta di analizzare la rappresentazione di stringa di una data e di un'ora usando le convenzioni di formattazione di altre impostazioni cultura.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 utilizza 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)

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

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

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 è null.s is null.

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, questo metodo restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Local e converte la data e l'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 viene eseguita alcuna conversione del fuso orario e viene restituito un valore DateTime la cui proprietà Kind è 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 lo stile DateTimeStyles.AllowWhiteSpaces.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

EsempioExample

Nell'esempio seguente viene analizzata una matrice di stringhe di data utilizzando le convenzioni delle impostazioni cultura en-US, fr-FR e de-DE.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Dimostra 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)

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

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

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)

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

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

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

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 è null.s is null.

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 l'ora in s e imposta la proprietà Kind del valore DateTime restituito come segue: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 Kind (proprietà)Kind property
s non contiene informazioni sul fuso orario.s contains no time zone information. Nessuno.None. DateTimeKind.Unspecified
s contiene le informazioni sul fuso orario.s contains time zone information. All'ora del fuso orario localeTo the time in the local time zone DateTimeKind.Local
s contiene le informazioni sul fuso orario e styles include il flag DateTimeStyles.AdjustToUniversal.s contains time zone information, and styles includes the DateTimeStyles.AdjustToUniversal flag. All'ora UTC (Coordinated Universal Time)To Coordinated Universal Time (UTC) DateTimeKind.Utc
s contiene la designazione 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. DateTimeKind.Utc

EsempioExample

Nell'esempio seguente viene illustrato il metodo Parse(String, IFormatProvider, DateTimeStyles) e viene visualizzato il valore della proprietà Kind dei valori DateTime risultanti.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