DateTime.ParseExact Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'equivalente DateTime. Il formato della rappresentazione di stringa deve corrispondere esattamente a un formato specificato; in caso contrario, verrà generata un'eccezione.

Overload

ParseExact(String, String, IFormatProvider)	Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo oggetto DateTime equivalente usando il formato specificato e le informazioni sul formato relative alle impostazioni cultura specificate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice specificata di formati, informazioni sul formato specifiche delle impostazioni cultura e stile. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione.
ParseExact(String, String, IFormatProvider, DateTimeStyles)	Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione.
ParseExact(String, String[], IFormatProvider, DateTimeStyles)	Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione.

Commenti

Importante

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

ParseExact(String, String, IFormatProvider)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Converte una determinata rappresentazione di stringa di una data e di un'ora nel relativo oggetto DateTime equivalente usando il formato specificato e le informazioni sul formato relative alle impostazioni cultura specificate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider);

public static DateTime ParseExact (string s, string format, IFormatProvider provider);

public static DateTime ParseExact (string s, string format, IFormatProvider? provider);

static member ParseExact : string * string * IFormatProvider -> DateTime

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider) As DateTime

Parametri

s: String

Stringa che contiene una data e un'ora da convertire.

format: String

Identificatore di formato che definisce il formato richiesto di s. Per altre informazioni, vedere la sezione Osservazioni.

provider: IFormatProvider

Oggetto che fornisce informazioni sul formato di s specifiche delle impostazioni cultura.

Restituisce

DateTime

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

Eccezioni

ArgumentNullException

s o format è null.

FormatException

s o format è una stringa vuota.

-oppure-

s non contiene una data e un'ora che corrispondono al criterio specificato in format.

-oppure-

Il componente relativo alle ore e l'identificatore AM/PM in s non corrispondono.

Esempio

Nell'esempio seguente viene illustrato il ParseExact metodo.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString, format;
      DateTime result;
      CultureInfo provider = CultureInfo.InvariantCulture;

      // Parse date-only value with invariant culture.
      dateString = "06/15/2008";
      format = "d";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date-only value without leading zero in month using "d" format.
      // Should throw a FormatException because standard short date pattern of
      // invariant culture requires two-digit month.
      dateString = "6/15/2008";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
      format = "ddd dd MMM yyyy h:mm tt zzz";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse date and time with offset but without offset's minutes.
      // Should throw a FormatException because "zzz" specifier requires leading
      // zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      dateString = "15/06/2008 08:30";
      format = "g";
      provider = new CultureInfo("fr-FR");
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }

      // Parse a date that includes seconds and milliseconds
      // by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542";
      format = "dd/MM/yyyy HH:mm:ss.ffffff";
      try {
         result = DateTime.ParseExact(dateString, format, provider);
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("{0} is not in the correct format.", dateString);
      }
   }
}
// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let provider = CultureInfo.InvariantCulture

    // Parse date-only value with invariant culture.
    let dateString = "06/15/2008"
    let format = "d"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date-only value without leading zero in month using "d" format.
    // Should throw a FormatException because standard short date pattern of
    // invariant culture requires two-digit month.
    let dateString = "6/15/2008"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with custom specifier.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
    let format = "ddd dd MMM yyyy h:mm tt zzz"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse date and time with offset but without offset's minutes.
    // Should throw a FormatException because "zzz" specifier requires leading
    // zero in hours.
    let dateString = "Sun 15 Jun 2008 8:30 AM -06"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    let dateString = "15/06/2008 08:30"
    let format = "g"
    let provider = CultureInfo "fr-FR"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    // Parse a date that includes seconds and milliseconds
    // by using the French (France) and invariant cultures.
    let dateString = "18/08/2015 06:30:15.006542"
    let format = "dd/MM/yyyy HH:mm:ss.ffffff"
    try
        let result = DateTime.ParseExact(dateString, format, provider)
        printfn $"{dateString} converts to {result}."
    with :? FormatException ->
        printfn $"{dateString} is not in the correct format."

    0

// The example displays the following output:
//       06/15/2008 converts to 6/15/2008 12:00:00 AM.
//       6/15/2008 is not in the correct format.
//       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
//       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
//       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
//       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString, format As String  
      Dim result As Date
      Dim provider As CultureInfo = CultureInfo.InvariantCulture

      ' Parse date-only value with invariant culture.
      dateString = "06/15/2008"
      format = "d"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 

      ' Parse date-only value without leading zero in month using "d" format.
      ' Should throw a FormatException because standard short date pattern of 
      ' invariant culture requires two-digit month.
      dateString = "6/15/2008"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with custom specifier.
      dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
      format = "ddd dd MMM yyyy h:mm tt zzz"        
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse date and time with offset but without offset's minutes.
      ' Should throw a FormatException because "zzz" specifier requires leading  
      ' zero in hours.
      dateString = "Sun 15 Jun 2008 8:30 AM -06"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try 
      
      ' Parse a date string using the French (France) culture.
      dateString = "15/06/2008 08:30"
      format = "g"
      provider = New CultureInfo("fr-FR")
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try

      ' Parse a date that includes seconds and milliseconds
      ' by using the French (France) and invariant cultures.
      dateString = "18/08/2015 06:30:15.006542"
      format = "dd/MM/yyyy HH:mm:ss.ffffff"
      Try
         result = Date.ParseExact(dateString, format, provider)
         Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
      Catch e As FormatException
         Console.WriteLine("{0} is not in the correct format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'       06/15/2008 converts to 6/15/2008 12:00:00 AM.
'       6/15/2008 is not in the correct format.
'       Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 7:30:00 AM.
'       Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.
'       15/06/2008 08:30 converts to 6/15/2008 8:30:00 AM.
'       18/08/2015 06:30:15.006542 converts to 8/18/2015 6:30:15 AM.

Commenti

Il DateTime.ParseExact(String, String, IFormatProvider) metodo analizza la rappresentazione di stringa di una data, che deve essere nel formato definito dal format parametro . È inoltre necessario che gli <elementi Date> e <Time> della rappresentazione di stringa di una data e dell'ora vengano visualizzati nell'ordine specificato da formate che s non contengano spazi vuoti diversi da quelli consentiti da format. Se format definisce una data senza alcun elemento ora e l'operazione di analisi ha esito positivo, il valore risultante DateTime ha un'ora di mezzanotte (00:00:00). Se format definisce un'ora senza alcun elemento di data e l'operazione di analisi ha esito positivo, il valore risultante DateTime ha una data di DateTime.Now.Date.

Se s non rappresenta un'ora in un determinato fuso orario e l'operazione di analisi ha esito positivo, la Kind proprietà del valore restituito DateTime è DateTimeKind.Unspecified. Se s rappresenta l'ora in un particolare fuso orario e format consente la presenza delle informazioni sul fuso orario , ad esempio se format è uguale agli identificatori di formato standard "o", "r" o "u" oppure se contiene gli identificatori di formato personalizzati "z", "zz" o "zzz", la Kind proprietà del valore restituito DateTime è DateTimeKind.Local.

Il format parametro è una stringa che contiene un singolo identificatore di formato standard o uno o più identificatori di formato personalizzati che definiscono il formato richiesto di s. Per informazioni dettagliate sui codici di formattazione validi, vedere Stringhe di formato data e ora standard o stringhe di formato data e ora personalizzate.

Nota

Se format è un modello di formato personalizzato che non include separatori di data o ora ,ad esempio "yyyyMMddHmm"), usare le impostazioni cultura invarianti per il provider parametro e il formato più ampio di ogni identificatore di formato personalizzato. Ad esempio, se si desidera specificare ore nel modello di formato, specificare il formato più ampio, "HH", anziché il formato più stretto, "H".

I simboli e le stringhe di data e ora specifici (ad esempio i nomi dei giorni della settimana in una determinata lingua) usati in s sono definiti dal provider parametro , come è il formato preciso di se format è una stringa di identificatore di s formato standard. Il provider parametro può essere uno dei seguenti:

Oggetto CultureInfo che rappresenta le impostazioni cultura utilizzate per interpretare s. L'oggetto DateTimeFormatInfo restituito dalla relativa DateTimeFormat proprietà definisce i simboli e la formattazione in s.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.
Implementazione personalizzata IFormatProvider il cui GetFormat metodo restituisce l'oggetto CultureInfo o l'oggetto DateTimeFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene utilizzato l'oggetto CultureInfo che corrisponde alle impostazioni cultura correnti.

Note per i chiamanti

In .NET Framework 4 il ParseExact metodo genera un'eccezione FormatException se la stringa da analizzare contiene un componente di ora e un designatore AM/PM che non sono in accordo. In .NET Framework 3.5 e versioni precedenti, l'iniziatore AM/PM viene ignorato.

Vedi anche

Si applica a

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione.

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametri

s: ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano una data e ora da convertire.

format: ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano un identificatore di formato che definisce il formato richiesto di s.

provider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a s.

style: DateTimeStyles

Combinazione bit per bit dei valori di enumerazione che fornisce informazioni aggiuntive su s, sugli elementi di stile che possono essere presenti in s o sulla conversione da s a un valore DateTime. Un valore tipico da specificare è None.

Restituisce

DateTime

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

Si applica a

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice specificata di formati, informazioni sul formato specifiche delle impostazioni cultura e stile. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione.

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

public static DateTime ParseExact (ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, Optional style As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parametri

s: ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano una data e ora da convertire.

formats: String[]

Matrice di formati consentiti di s.

provider: IFormatProvider

Oggetto che fornisce informazioni sul formato di s specifiche delle impostazioni cultura.

style: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di s. Un valore tipico da specificare è None.

Restituisce

DateTime

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

Si applica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. In caso contrario, verrà generata un'eccezione.

public:
 static DateTime ParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string format, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles) As DateTime

Parametri

s: String

Stringa contenente data e ora da convertire.

format: String

Identificatore di formato che definisce il formato richiesto di s. Per altre informazioni, vedere la sezione Osservazioni.

provider: IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a s.

style: DateTimeStyles

Restituisce

DateTime

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

Eccezioni

ArgumentNullException

s o format è null.

FormatException

s o format è una stringa vuota.

-oppure-

s non contiene una data e un'ora che corrispondono al criterio specificato in format.

-oppure-

Il componente relativo alle ore e l'identificatore AM/PM in s non corrispondono.

ArgumentException

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

Esempio

Nell'esempio seguente viene illustrato il ParseExact(String, String, IFormatProvider) metodo. Si noti che la stringa " 01/5/2009 8:30 AM" non può essere analizzata correttamente quando il styles parametro è uguale a perché gli spazi iniziali non sono consentiti DateTimeStyles.None da format. Inoltre, la stringa "5/01/2009 09:00" non può essere analizzata correttamente con un format valore di "MM/gg/yyyyhh:mm" perché la stringa di data non precede il numero del mese con uno zero iniziale, come format richiesto.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = new CultureInfo("en-US");
      string dateString;
      DateTime dateValue;

      // Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM";
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00";
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      // Allow a leading space in the date string.
      try {
         dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                                     DateTimeStyles.AdjustToUniversal);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
      try {
         dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.RoundtripKind);
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      }
      catch (FormatException) {
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
      }
   }
}
// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let enUS = CultureInfo "en-US"

    // Parse date with no style flags.
    let dateString = " 5/01/2009 8:30 AM"
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."
    
    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Use custom formats with M and MM.
    let dateString = "5/01/2009 09:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string with time zone information.
    let dateString = "05/01/2009 01:30:42 PM -05:00"
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    try
        let dateValue = DateTime.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Parse a string representing UTC.
    let dateString = "2008-06-11T16:11:20.0904778Z"
    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."

    try
        let dateValue = DateTime.ParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind)
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    with :? FormatException ->
        printfn $"'{dateString}' is not in an acceptable format."


// The example displays the following output:
//    ' 5/01/2009 8:30 AM' is not in an acceptable format.
//    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
//    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
//    '5/01/2009 09:00' is not in an acceptable format.
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
//    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
//    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim enUS As New CultureInfo("en-US") 
      Dim dateString As String
      Dim dateValue As Date
      
      ' Parse date with no style flags.
      dateString = " 5/01/2009 8:30 AM"
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      Try
         dateValue = Date.ParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      ' Allow a leading space in the date string.
      Try
         dateValue = Date.ParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                                     DateTimeStyles.AdjustToUniversal)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
      Try
         dateValue = Date.ParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.RoundtripKind)
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Catch e As FormatException
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End Try
   End Sub
End Module
' The example displays the following output:
'    ' 5/01/2009 8:30 AM' is not in an acceptable format.
'    Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
'    Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
'    '5/01/2009 09:00' is not in an acceptable format.
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
'    Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
'    Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).

Commenti

Il DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodo analizza la rappresentazione di stringa di una data, che deve essere in un formato definito dal format parametro . Richiede inoltre che gli elementi di data e ora in s vengano visualizzati nell'ordine specificato da format. Se s non corrisponde al modello del format parametro, con eventuali varianti definite dal style parametro , il metodo genera un'eccezione FormatException. Al contrario, il DateTime.Parse(String, IFormatProvider, DateTimeStyles) metodo analizza la rappresentazione stringa di una data in uno dei formati riconosciuti dall'oggetto del DateTimeFormatInfo provider di formato. Il DateTime.Parse(String, IFormatProvider, DateTimeStyles) metodo consente anche agli elementi data e ora in di essere visualizzati in s qualsiasi ordine.

Se il s parametro contiene solo un'ora e nessuna data, la data corrente viene usata a meno che il style parametro includa il flag, in cui viene usata la DateTimeStyles.NoCurrentDateDefault data predefinita (DateTime.Date.MinValue). Se il s parametro contiene solo una data e nessuna ora, viene usata la mezzanotte (00:00:00). Il style parametro determina anche se il s parametro può contenere caratteri di spazio vuoto iniziali, interni o finali.

Se s non contiene informazioni sul fuso orario, la Kind proprietà dell'oggetto restituito DateTime è DateTimeKind.Unspecified. Questo comportamento può essere modificato usando il DateTimeStyles.AssumeLocal flag, che restituisce un valore la cui Kind proprietà è , o usando i flag eDateTimeStyles.AdjustToUniversal, che restituisce un DateTime DateTime valore la DateTimeStyles.AssumeUniversal cui Kind proprietà è DateTimeKind.Local DateTimeKind.Utc. Se s contiene informazioni sul fuso orario, l'ora viene convertita in ora locale, se necessario e la Kind proprietà dell'oggetto restituito è impostata DateTime su DateTimeKind.Local. Questo comportamento può essere modificato usando il flag per non convertire l'ora DateTimeStyles.RoundtripKind UTC (Coordinated Universal Time) in un'ora locale e per impostare la Kind proprietà su DateTimeKind.Utc.

Il format parametro definisce il modello richiesto del s parametro. Può essere costituito da uno o più identificatori di formato personalizzati dalla tabella Stringhe di formato data e ora personalizzate o da un singolo identificatore di formato standard, che identifica un modello predefinito, dalla tabella Stringhe di formato data e ora standard.

Se non si usano separatori di data o ora in un modello di formato personalizzato, usare le impostazioni cultura invarianti per il provider parametro e la forma più ampia di ogni identificatore di formato personalizzato. Ad esempio, se si desidera specificare ore nel modello, specificare la forma più ampia, "HH", anziché la forma più stretta, "H".

Nota

Anziché richiedere che sia s conforme a un singolo formato per l'operazione di analisi con esito positivo, è possibile chiamare il DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metodo e specificare più formati consentiti. Ciò rende più probabile che l'operazione di analisi abbia esito positivo.

Il styles parametro include uno o più membri dell'enumerazione DateTimeStyles che determinano se e dove spazio vuoto non definito da format può essere visualizzato s e che controlla il comportamento preciso dell'operazione di analisi. Nella tabella seguente viene descritto il modo in cui ogni membro dell'enumerazione DateTimeStyles influisce sull'operazione del ParseExact(String, String, IFormatProvider, DateTimeStyles) metodo.

Membro DateTimeStyles	Descrizione
AdjustToUniversal	Analizza e, se necessario, lo converte `s` in UTC. Se `s` include un offset del fuso orario o se `s` non contiene informazioni `styles` sul fuso orario, il metodo analizza la DateTimeStyles.AssumeLocal stringa, chiama ToUniversalTime per convertire il valore restituito DateTime in UTC e imposta la Kind proprietà su DateTimeKind.Utc. Se `s` indica che rappresenta l'ora UTC o se `s` non contiene informazioni sul fuso orario, ma `styles` include il flag, il metodo analizza la DateTimeStyles.AssumeUniversal stringa, non esegue alcuna conversione del fuso orario sul valore restituito DateTime e imposta la Kind proprietà su DateTimeKind.Utc. In tutti gli altri casi il flag non ha alcun effetto.
AllowInnerWhite	Specifica che lo spazio vuoto non definito da `format` può essere visualizzato tra qualsiasi singolo elemento di data o ora.
AllowLeadingWhite	Specifica che lo spazio vuoto non definito da `format` può essere visualizzato all'inizio di `s`.
AllowTrailingWhite	Specifica che lo spazio vuoto non definito da `format` può essere visualizzato alla fine di `s`.
AllowWhiteSpaces	Specifica che `s` può contenere spazi vuoti iniziali, interni e finali non definiti da `format`.
AssumeLocal	Specifica che se `s` manca qualsiasi informazione del fuso orario, si presuppone che rappresenti un'ora locale. A meno che il DateTimeStyles.AdjustToUniversal flag non sia presente, la Kind proprietà del valore restituito è impostata DateTime su DateTimeKind.Local.
AssumeUniversal	Specifica che se `s` non sono presenti informazioni sul fuso orario, si presuppone che rappresenti l'ora UTC. A meno che il DateTimeStyles.AdjustToUniversal flag non sia presente, il metodo converte il valore restituito DateTime dall'ora UTC all'ora locale e imposta la relativa Kind proprietà su DateTimeKind.Local.
NoCurrentDateDefault	Se `s` contiene l'ora senza informazioni sulla data, la data del valore restituito è impostata su `DateTime.MinValue.Date`.
None	Il `s` parametro viene analizzato usando i valori predefiniti. Non è consentito spazio vuoto diverso da quello presente in `format` . Se `s` manca un componente di data, la data del valore restituito DateTime è impostata su 1/1/0001. Se `s` non contiene informazioni sul fuso orario, la Kind proprietà dell'oggetto restituito è impostata DateTime su DateTimeKind.Unspecified. Se le informazioni sul fuso orario sono presenti in , l'ora viene convertita nell'ora `s`locale e la Kind proprietà dell'oggetto restituito è impostata DateTime su DateTimeKind.Local.
RoundtripKind	Per le stringhe che contengono informazioni sul fuso orario, tenta di impedire la conversione in una DateTime data e un'ora di valore con la relativa Kind proprietà impostata su DateTimeKind.Local. Questo flag impedisce principalmente la conversione degli orari UTC in orari locali.

I simboli e le stringhe di data e ora specifici (ad esempio i nomi dei giorni della settimana in una determinata lingua) usati in s sono definiti dal provider parametro, come è il formato preciso di s se format è una stringa di identificatore di formato standard. Il provider parametro può essere uno dei seguenti:

Oggetto CultureInfo che rappresenta le impostazioni cultura usate per interpretare s. L'oggetto DateTimeFormatInfo restituito dalla relativa DateTimeFormat proprietà definisce i simboli e la formattazione in s.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.
Implementazione personalizzata IFormatProvider il cui GetFormat metodo restituisce l'oggetto o l'oggetto CultureInfo DateTimeFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene usato l'oggetto CultureInfo corrispondente alle impostazioni cultura correnti.

Note per i chiamanti

Vedi anche

Si applica a

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Source:: DateTime.cs

Source:: DateTime.cs

Source:: DateTime.cs

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati; in caso contrario, verrà generata un'eccezione.

public:
 static DateTime ParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style);

public static DateTime ParseExact (string s, string[] formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime

Public Shared Function ParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles) As DateTime

Parametri

s: String

Stringa che contiene una data e un'ora da convertire.

formats: String[]

Matrice di formati consentiti di s. Per altre informazioni, vedere la sezione Osservazioni.

provider: IFormatProvider

Oggetto che fornisce informazioni sul formato di s specifiche delle impostazioni cultura.

style: DateTimeStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di s. Un valore tipico da specificare è None.

Restituisce

DateTime

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

Eccezioni

ArgumentNullException

s o formats è null.

FormatException

Il parametro s è una stringa vuota.

-oppure-

un elemento di formats è una stringa vuota.

-oppure-

s non contiene data e ora che corrispondano a elementi di formats.

-oppure-

Il componente relativo alle ore e l'identificatore AM/PM in s non corrispondono.

ArgumentException

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

Esempio

Nell'esempio seguente viene usato il DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metodo per assicurarsi che una stringa in diversi formati possibili possa essere analizzata correttamente.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats= {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt",
                         "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss",
                         "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt",
                         "M/d/yyyy h:mm", "M/d/yyyy h:mm",
                         "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
                         "MM/d/yyyy HH:mm:ss.ffffff" };
      string[] dateStrings = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM",
                              "5/1/2009 6:32:00", "05/01/2009 06:32",
                              "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
                              "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" };
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         try {
            dateValue = DateTime.ParseExact(dateString, formats,
                                            new CultureInfo("en-US"),
                                            DateTimeStyles.None);
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         }
         catch (FormatException) {
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString);
         }
      }
   }
}
// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

open System
open System.Globalization

let formats = 
    [| "M/d/yyyy h:mm:ss tt"; "M/d/yyyy h:mm tt"
       "MM/dd/yyyy hh:mm:ss"; "M/d/yyyy h:mm:ss"
       "M/d/yyyy hh:mm tt"; "M/d/yyyy hh tt"
       "M/d/yyyy h:mm"; "M/d/yyyy h:mm"
       "MM/dd/yyyy hh:mm"; "M/dd/yyyy hh:mm"
       "MM/d/yyyy HH:mm:ss.ffffff" |]

let dateStrings = 
    [ "5/1/2009 6:32 PM"; "05/01/2009 6:32:05 PM"
      "5/1/2009 6:32:00"; "05/01/2009 06:32"
      "05/01/2009 06:32:00 PM"; "05/01/2009 06:32:00"
      "08/28/2015 16:17:39.125"; "08/28/2015 16:17:39.125000" ]

for dateString in dateStrings do
    try
        let dateValue = DateTime.ParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None)
        printfn $"Converted '{dateString}' to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}' to a date."

// The example displays the following output:
//       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
//       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
//       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
//       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
//       Unable to convert '08/28/2015 16:17:39.125' to a date.
//       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim formats() As String = {"M/d/yyyy h:mm:ss tt", "M/d/yyyy h:mm tt", _
                                 "MM/dd/yyyy hh:mm:ss", "M/d/yyyy h:mm:ss", _
                                 "M/d/yyyy hh:mm tt", "M/d/yyyy hh tt", _
                                 "M/d/yyyy h:mm", "M/d/yyyy h:mm", _
                                 "MM/dd/yyyy hh:mm", "M/dd/yyyy hh:mm",
                                 "MM/d/yyyy HH:mm:ss.ffffff" }
      Dim dateStrings() As String = {"5/1/2009 6:32 PM", "05/01/2009 6:32:05 PM", _
                                     "5/1/2009 6:32:00", "05/01/2009 06:32", _
                                     "05/01/2009 06:32:00 PM", "05/01/2009 06:32:00",
                                     "08/28/2015 16:17:39.125", "08/28/2015 16:17:39.125000" }

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         Try
            dateValue = DateTime.ParseExact(dateString, formats, _
                                            New CultureInfo("en-US"), _
                                            DateTimeStyles.None)
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Catch e As FormatException
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End Try                                               
      Next
   End Sub
End Module
' The example displays the following output:
'       Converted '5/1/2009 6:32 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 6:32:05 PM' to 5/1/2009 6:32:05 PM.
'       Converted '5/1/2009 6:32:00' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32' to 5/1/2009 6:32:00 AM.
'       Converted '05/01/2009 06:32:00 PM' to 5/1/2009 6:32:00 PM.
'       Converted '05/01/2009 06:32:00' to 5/1/2009 6:32:00 AM.
'       Unable to convert '08/28/2015 16:17:39.125' to a date.
'       Converted '08/28/2015 16:17:39.125000' to 8/28/2015 4:17:39 PM.

Commenti

Il DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metodo analizza la rappresentazione stringa di una data corrispondente a uno dei modelli assegnati al formats parametro. Se la stringa s non corrisponde a uno di questi modelli con una delle varianti definite dal styles parametro, il metodo genera un FormatExceptionoggetto . Oltre a confrontare s più modelli di formattazione, anziché a un unico modello di formattazione, questo overload si comporta in modo identico al DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodo.

Il s parametro contiene la data e l'ora da analizzare. Se il s parametro contiene solo un'ora e nessuna data, la data corrente viene usata a meno che il style parametro includa il flag, in cui viene usata la DateTimeStyles.NoCurrentDateDefault data predefinita (DateTime.Date.MinValue). Se il s parametro contiene solo una data e nessuna ora, viene usata la mezzanotte (00:00:00). Il style parametro determina anche se il s parametro può contenere caratteri di spazi vuoti iniziali, interni o finali diversi da quelli consentiti da una delle stringhe di formato in formats.

Il formats parametro contiene una matrice di modelli, una delle quali s deve corrispondere esattamente se l'operazione di analisi deve avere esito positivo. I modelli nel formats parametro sono costituiti da uno o più identificatori di formato personalizzati dalla tabella Stringhe di formato data e ora personalizzate o da un singolo identificatore di formato standard, che identifica un modello predefinito, dalla tabella Stringhe di formato data e ora standard.

Membro DateTimeStyles	Descrizione
AdjustToUniversal	Analizza e, se necessario, lo converte `s` in UTC. Se `s` include un offset del fuso orario o se `s` non contiene informazioni `styles` sul fuso orario, il metodo analizza la DateTimeStyles.AssumeLocal stringa, chiama ToUniversalTime per convertire il valore restituito DateTime in UTC e imposta la Kind proprietà su DateTimeKind.Utc. Se `s` indica che rappresenta l'ora UTC o se `s` non contiene informazioni sul fuso orario, ma `styles` include il flag, il metodo analizza la DateTimeStyles.AssumeUniversal stringa, non esegue alcuna conversione del fuso orario sul valore restituito DateTime e imposta la Kind proprietà su DateTimeKind.Utc. In tutti gli altri casi il flag non ha alcun effetto.
AllowInnerWhite	Specifica che lo spazio vuoto non definito da `format` può essere visualizzato tra qualsiasi singolo elemento di data o ora.
AllowLeadingWhite	Specifica che lo spazio vuoto non definito da `format` può essere visualizzato all'inizio di `s`.
AllowTrailingWhite	Specifica che lo spazio vuoto non definito da `format` può essere visualizzato alla fine di `s`.
AllowWhiteSpaces	Specifica che `s` può contenere spazi vuoti iniziali, interni e finali non definiti da `format`.
AssumeLocal	Specifica che se `s` manca qualsiasi informazione del fuso orario, si presuppone che rappresenti un'ora locale. A meno che il DateTimeStyles.AdjustToUniversal flag non sia presente, la Kind proprietà del valore restituito è impostata DateTime su DateTimeKind.Local.
AssumeUniversal	Specifica che, se `s` mancano informazioni sul fuso orario, si presuppone che rappresenti l'ora UTC. A meno che il DateTimeStyles.AdjustToUniversal flag non sia presente, il metodo converte il valore restituito DateTime dall'ora UTC all'ora locale e imposta la relativa Kind proprietà su DateTimeKind.Local.
NoCurrentDateDefault	Se `s` contiene un'ora senza informazioni sulla data, la data del valore restituito viene impostata su `DateTime.MinValue.Date`.
None	Il `s` parametro viene analizzato usando i valori predefiniti. Non sono consentiti spazi vuoti diversi da quelli presenti in `format` . Se `s` manca un componente di data, la data del valore restituito viene impostata DateTime su 1/1/0001. Se `s` non contiene informazioni sul fuso orario, la Kind proprietà dell'oggetto restituito viene impostata DateTime su DateTimeKind.Unspecified. Se le informazioni sul fuso orario sono presenti in , l'ora viene convertita nell'ora `s`locale e la Kind proprietà dell'oggetto restituito viene impostata DateTime su DateTimeKind.Local.
RoundtripKind	Per le stringhe che contengono informazioni sul fuso orario, tenta di impedire la conversione in una data e un'ora con la relativa Kind proprietà impostata su DateTimeKind.Local. Questo flag impedisce principalmente la conversione di ore UTC in ore locali.

Oggetto CultureInfo che rappresenta le impostazioni cultura utilizzate per interpretare s. L'oggetto DateTimeFormatInfo restituito dalla relativa DateTimeFormat proprietà definisce i simboli e la formattazione in s.
Oggetto DateTimeFormatInfo che definisce il formato dei dati di data e ora.
Implementazione personalizzata IFormatProvider il cui GetFormat metodo restituisce l'oggetto CultureInfo o l'oggetto DateTimeFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene utilizzato l'oggetto CultureInfo che corrisponde alle impostazioni cultura correnti.

Note per i chiamanti

In .NET Framework 4 il ParseExact metodo genera un valore se la stringa da analizzare contiene un FormatException componente ora e un designatore AM/PM non in accordo. Nelle versioni precedenti e .NET Framework 3.5 viene ignorato il designatore AM/PM.

Vedi anche

Si applica a

DateTime.ParseExact Metodo

Definizione

Overload

Commenti

ParseExact(String, String, IFormatProvider)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parametri

Restituisce

Si applica a

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

Parametri

Restituisce

Si applica a

ParseExact(String, String, IFormatProvider, DateTimeStyles)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Note per i chiamanti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive