DateTime.ParseExact Metodo

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

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

Restituisce

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

Eccezioni

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.

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

• TryParseExact
• CultureInfo
• DateTimeFormatInfo
• Analisi delle stringhe di data e ora in .NET Framework
• Stringhe di formato data e ora standard
• Stringhe di formato di data e ora personalizzate

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

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

Restituisce

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

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

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

Restituisce

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

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

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

Restituisce

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

Eccezioni

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 DateTimeDateTime valore la DateTimeStyles.AssumeUniversal cui Kind proprietà è DateTimeKind.LocalDateTimeKind.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".

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.

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 CultureInfoDateTimeFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene usato l'oggetto CultureInfo corrispondente 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

• TryParseExact
• CultureInfo
• DateTimeFormatInfo
• Analisi delle stringhe di data e ora in .NET Framework
• Stringhe di formato data e ora standard
• Stringhe di formato data e ora personalizzate

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

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

Restituisce

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

Eccezioni

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.

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 DateTimeDateTime valore la DateTimeStyles.AssumeUniversal cui Kind proprietà è DateTimeKind.LocalDateTimeKind.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 impostare la Kind proprietà su DateTimeKind.Utc.

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.

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".

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.

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

• TryParseExact
• CultureInfo
• DateTimeFormatInfo
• Analisi delle stringhe di data e ora in .NET Framework
• Stringhe di formato data e ora standard
• Stringhe di formato di data e ora personalizzate