DateTime.TryParseExact Metodo

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

public:
 static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

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

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametri

Restituisce

true se s è stata convertita correttamente; in caso contrario, false.

Eccezioni

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

public:
 static bool TryParseExact(ReadOnlySpan<char> s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(ReadOnlySpan<char> s, string?[]? formats, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

public static bool TryParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

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

Public Shared Function TryParseExact (s As ReadOnlySpan(Of Char), formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametri

Restituisce

true se s è stata convertita correttamente; in caso contrario, false.

Eccezioni

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

public:
 static bool TryParseExact(System::String ^ s, System::String ^ format, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(string s, string format, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

public static bool TryParseExact(string? s, string? format, IFormatProvider? provider, System.Globalization.DateTimeStyles style, out DateTime result);

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

Public Shared Function TryParseExact (s As String, format As String, provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametri

Restituisce

true se s è stata convertita correttamente; in caso contrario, false.

Eccezioni

Esempio

Nell'esempio seguente viene illustrato il DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metodo . Si noti che la stringa " 01/5/2009 8:30 AM" non può essere analizzata correttamente quando il styles parametro è uguale DateTimeStyles.None a perché gli spazi iniziali non sono consentiti da format. Inoltre, la stringa "5/01/2009 09:00" non può essere analizzata correttamente con " format 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";
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "g", enUS,
                                 DateTimeStyles.AllowLeadingWhite, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Use custom formats with M and MM.
      dateString = "5/01/2009 09:00";
      if (DateTime.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS,
                                 DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         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";
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Allow a leading space in the date string.
      if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS,
                              DateTimeStyles.AdjustToUniversal, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      // Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z";
      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                     DateTimeStyles.None, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString);

      if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture,
                                 DateTimeStyles.RoundtripKind, out dateValue))
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue,
                           dateValue.Kind);
      else
         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"
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."              
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

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

    // Allow a leading space in the date string.
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        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"
    match DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

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

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

    match DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"'{dateString}' is not in an acceptable format."

    0

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

Public 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"
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "g", enUS, _
                            DateTimeStyles.AllowLeadingWhite, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      ' Use custom formats with M and MM.
      dateString = "5/01/2009 09:00"
      If Date.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If

      ' Parse a string with time zone information.
      dateString = "05/01/2009 01:30:42 PM -05:00" 
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      ' Allow a leading space in the date string.
      If Date.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, _
                            DateTimeStyles.AdjustToUniversal, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
           
      ' Parse a string representing UTC.
      dateString = "2008-06-11T16:11:20.0904778Z"
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                                     DateTimeStyles.None, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
      
      If Date.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, _
                            DateTimeStyles.RoundtripKind, dateValue) Then
         Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, _
                           dateValue.Kind)
      Else
         Console.WriteLine("'{0}' is not in an acceptable format.", dateString)
      End If
   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.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metodo analizza la rappresentazione di stringa di una data, che deve essere nel formato definito dal format parametro . È simile al metodo DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles), ad eccezione del fatto che il metodo TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) non lancia un'eccezione se la conversione non riesce.

Il s parametro contiene la data e l'ora da analizzare e deve essere in un formato definito dal format parametro . Se gli elementi di data, ora e fuso orario sono presenti in s, devono essere visualizzati anche nell'ordine specificato da format. Se format definisce una data senza elemento time 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 elemento date e l'operazione di analisi ha esito positivo, il valore risultante DateTime per impostazione predefinita ha una data di DateTime.Now.Dateo ha una data di DateTime.MinValue.Date se styles include il DateTimeStyles.NoCurrentDateDefault flag . Il style parametro determina se il s parametro può contenere spazi vuoti 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 DateTime valore la cui Kind proprietà è DateTimeKind.Localo utilizzando i DateTimeStyles.AssumeUniversal flag e DateTimeStyles.AdjustToUniversal , che restituisce un DateTime valore la cui Kind proprietà è DateTimeKind.Utc. Se contiene informazioni sul fuso orario, l'ora viene convertita in ora locale, se necessario e la Kind proprietà dell'oggetto restituito viene 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 format parametro contiene un criterio che corrisponde al formato previsto del s parametro. Il modello nel format parametro è 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 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 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 parametro provider 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.

Il styles parametro include uno o più membri dell'enumerazione DateTimeStyles che determinano se e dove gli spazi vuoti non definiti da format possono essere visualizzati in s e che controllano 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 TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metodo .

Membro DateTimeStyles	Descrizione
AdjustToUniversal	Analizza e, se necessario, lo converte s in formato UTC. Se s include una differenza di fuso orario o se s non contiene informazioni sul fuso orario ma styles include il DateTimeStyles.AssumeLocal flag , il metodo analizza la 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 DateTimeStyles.AssumeUniversal flag , il metodo analizza la 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 gli spazi vuoti non definiti da format possono essere visualizzati tra qualsiasi singolo elemento di data o ora.
AllowLeadingWhite	Specifica che gli spazi vuoti non definiti da format possono essere visualizzati all'inizio di s.
AllowTrailingWhite	Specifica che gli spazi vuoti non definiti da format possono essere visualizzati 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 non dispone di informazioni sul fuso orario, si presuppone che rappresenti un'ora locale. A meno che il DateTimeStyles.AdjustToUniversal indicatore non sia presente, la proprietà Kind del valore restituito viene impostata su DateTime.
AssumeUniversal	Specifica che, se s non dispone di 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 slocale 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 un DateTime valore con la relativa Kind proprietà impostata su DateTimeKind.Local. Questo flag impedisce principalmente la conversione di ore UTC in ore locali.

Note per i chiamanti

In .NET Framework 4, il TryParseExact metodo restituisce false se la stringa da analizzare contiene un componente ora e un designatore AM/PM che non sono in accordo. In .NET Framework 3.5 e versioni precedenti, il designatore AM/PM viene ignorato.

Vedi anche

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

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

Origine:

DateTime.cs

public:
 static bool TryParseExact(System::String ^ s, cli::array <System::String ^> ^ formats, IFormatProvider ^ provider, System::Globalization::DateTimeStyles style, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParseExact(string s, string[] formats, IFormatProvider provider, System.Globalization.DateTimeStyles style, out DateTime result);

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

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

Public Shared Function TryParseExact (s As String, formats As String(), provider As IFormatProvider, style As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametri

Restituisce

true se il s parametro è stato convertito correttamente; in caso contrario, false.

Eccezioni

Esempio

Nell'esempio seguente viene usato il DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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"};
      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"};
      DateTime dateValue;

      foreach (string dateString in dateStrings)
      {
         if (DateTime.TryParseExact(dateString, formats,
                                    new CultureInfo("en-US"),
                                    DateTimeStyles.None,
                                    out dateValue))
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue);
         else
            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.

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

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

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, CultureInfo "en-US", DateTimeStyles.None) with
    | true, dateValue ->
        printfn $"Converted '{dateString}' to {dateValue}."
    | _ ->
        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.

Imports System.Globalization

Public 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"}
      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"} 

      Dim dateValue As DateTime
      
      For Each dateString As String In dateStrings
         If Date.TryParseExact(dateString, formats, _
                               New CultureInfo("en-US"), _
                               DateTimeStyles.None, _
                               dateValue) Then
            Console.WriteLine("Converted '{0}' to {1}.", dateString, dateValue)
         Else
            Console.WriteLine("Unable to convert '{0}' to a date.", dateString)
         End If                                               
      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.

Commenti

Il DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metodo analizza la rappresentazione di stringa di una data corrispondente a uno dei modelli assegnati al formats parametro . È simile al metodo , ad eccezione del DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) fatto che il TryParseExact metodo non genera un'eccezione se la conversione non riesce.

Il s parametro contiene la data e l'ora da analizzare. Se il parametro contiene solo un'ora s e nessuna data, la data corrente viene utilizzata a meno che il style parametro non includa il DateTimeStyles.NoCurrentDateDefault flag, nel qual caso viene usata la 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 inoltre se il s parametro può contenere 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 DateTime valore la cui Kind proprietà è DateTimeKind.Localo utilizzando i DateTimeStyles.AssumeUniversal flag e DateTimeStyles.AdjustToUniversal , che restituisce un DateTime valore la cui Kind proprietà è DateTimeKind.Utc. Se contiene informazioni sul fuso orario, l'ora viene convertita in ora locale, se necessario e la Kind proprietà dell'oggetto restituito viene 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 della 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 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 parametro provider 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.

Il styles parametro include uno o più membri dell'enumerazione DateTimeStyles che determinano se e dove gli spazi vuoti non definiti da format possono essere visualizzati in s e che controllano 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 TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metodo .

Membro DateTimeStyles	Descrizione
AdjustToUniversal	Analizza e, se necessario, lo converte s in formato UTC. Se s include una differenza di fuso orario o se s non contiene informazioni sul fuso orario ma styles include il DateTimeStyles.AssumeLocal flag , il metodo analizza la 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 DateTimeStyles.AssumeUniversal flag , il metodo analizza la 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 gli spazi vuoti non definiti da format possono essere visualizzati tra qualsiasi singolo elemento di data o ora.
AllowLeadingWhite	Specifica che gli spazi vuoti non definiti da format possono essere visualizzati all'inizio di s.
AllowTrailingWhite	Specifica che gli spazi vuoti non definiti da format possono essere visualizzati 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 non dispone di informazioni sul fuso orario, si presuppone che rappresenti un'ora locale. A meno che il DateTimeStyles.AdjustToUniversal indicatore non sia presente, la proprietà Kind del valore restituito viene impostata su DateTime.
AssumeUniversal	Specifica che, se s non dispone di 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 slocale 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 un DateTime valore con la relativa Kind proprietà impostata su DateTimeKind.Local. Questo flag impedisce principalmente la conversione di ore UTC in ore locali.

Note per i chiamanti

In .NET Framework 4, il TryParseExact metodo restituisce false se la stringa da analizzare contiene un componente ora e un designatore AM/PM che non sono in accordo. In .NET Framework 3.5 e versioni precedenti, il designatore AM/PM viene ignorato.

Vedi anche

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