Condividi tramite

DateTime.TryParseExact Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
mscorlib.dll

Converte la rappresentazione di stringa specificata di una data e un'ora nel relativo DateTime equivalente. Il formato della rappresentazione di stringa deve corrispondere esattamente a un formato specificato. Il metodo restituisce un valore che indica se la conversione è riuscita.

Overload

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Converte la rappresentazione di intervallo specificata di una data e un'ora nel relativo DateTime equivalente utilizzando il formato specificato, le informazioni sul formato specifico delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è riuscita.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)

Converte l'intervallo di caratteri specificato di una data e un'ora nel relativo DateTime equivalente e restituisce un valore che indica se la conversione ha avuto esito positivo.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Converte la rappresentazione di stringa specificata di una data e un'ora nel relativo DateTime equivalente usando il formato specificato, le informazioni sul formato specifico delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è riuscita.
TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Converte la rappresentazione di stringa specificata di una data e un'ora nel relativo 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 a uno dei formati specificati. Il metodo restituisce un valore che indica se la conversione è riuscita.

Commenti

Importante

Le ere nei calendari giapponesi si basano sul regno dell'imperatore e quindi si prevede di cambiare. Ad esempio, il 1° maggio 2019 ha contrassegnato l'inizio dell'era Reiwa nel JapaneseCalendar e JapaneseLunisolarCalendar. Tale cambiamento di era influisce su 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 sui test delle applicazioni nei sistemi Windows per garantire la conformità alla modifica dell'era, vedere Preparare l'applicazione per la modifica dell'era giapponese. Per le funzionalità di .NET che supportano calendari con più ere e per le procedure consigliate quando si usano calendari che supportano più ere, vedere Uso delle era.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

Origine:
DateTime.cs
Origine:
DateTime.cs
Origine:
DateTime.cs

Converte la rappresentazione di intervallo specificata di una data e un'ora nel relativo DateTime equivalente utilizzando il formato specificato, le informazioni sul formato specifico delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è riuscita.

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

s
ReadOnlySpan<Char>

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

format
ReadOnlySpan<Char>

Formato obbligatorio di s.

provider
IFormatProvider

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

style
DateTimeStyles

Combinazione bit per bit di uno o più valori di enumerazione che indicano il formato consentito di s.

result
DateTime

Quando termina, questo metodo contiene il valore DateTime equivalente alla data e all'ora contenute in s, se la conversione è riuscita o DateTime.MinValue se la conversione non è riuscita. La conversione non riesce se il parametro s o format è null, è una stringa vuota o non contiene una data e un'ora che corrispondono al criterio specificato in format. Questo parametro viene passato non inizializzato.

Restituisce

Boolean

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

Si applica a

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

Origine:
DateTime.cs
Origine:
DateTime.cs
Origine:
DateTime.cs

Converte l'intervallo di caratteri specificato di una data e un'ora nel relativo DateTime equivalente e restituisce un valore che indica se la conversione ha avuto esito positivo.

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

s
ReadOnlySpan<Char>

Intervallo contenente la stringa da analizzare.

formats
String[]

Matrice di formati consentiti di s.

provider
IFormatProvider

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

style
DateTimeStyles

Combinazione bit per bit di valori di enumerazione che definisce come interpretare la data analizzata in relazione al fuso orario corrente o alla data corrente. Un valore tipico da specificare è None.

result
DateTime

Quando termina, questo metodo contiene il valore DateTime equivalente alla data e all'ora contenute in s, se la conversione è riuscita o DateTime.MinValue se la conversione non è riuscita. La conversione non riesce se il parametro s è null, è Emptyo non contiene una rappresentazione di stringa valida di una data e ora. Questo parametro viene passato non inizializzato.

Restituisce

Boolean

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

Si applica a

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Origine:
DateTime.cs
Origine:
DateTime.cs
Origine:
DateTime.cs

Converte la rappresentazione di stringa specificata di una data e un'ora nel relativo DateTime equivalente usando il formato specificato, le informazioni sul formato specifico delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è riuscita.

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

s
String

Stringa contenente una data e un'ora da convertire.

format
String

Formato obbligatorio di s.

provider
IFormatProvider

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

style
DateTimeStyles

Combinazione bit per bit di uno o più valori di enumerazione che indicano il formato consentito di s.

result
DateTime

Quando termina, questo metodo contiene il valore DateTime equivalente alla data e all'ora contenute in s, se la conversione è riuscita o DateTime.MinValue se la conversione non è riuscita. La conversione non riesce se il parametro s o format è null, è una stringa vuota o non contiene una data e un'ora che corrispondono al criterio specificato in format. Questo parametro viene passato non inizializzato.

Restituisce

Boolean

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

Eccezioni

ArgumentException

style non è un valore di DateTimeStyles valido.

-o-

style contiene una combinazione non valida di valori di DateTimeStyles , ad esempio AssumeLocal e AssumeUniversal.

Esempio

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

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 metodo DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) analizza la rappresentazione di stringa di una data, che deve essere nel formato definito dal parametro format. È simile al metodo DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles), ad eccezione del fatto che il metodo TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) non genera un'eccezione se la conversione non riesce.

Il parametro s contiene la data e l'ora di analisi e deve essere in un formato definito dal parametro format. 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 alcun elemento time e l'operazione di analisi ha esito positivo, il valore DateTime risultante ha un'ora di mezzanotte (00:00:00). Se format definisce un'ora senza alcun elemento date e l'operazione di analisi ha esito positivo, il valore DateTime risultante ha una data di DateTime.Now.Dateoppure ha una data di DateTime.MinValue.Date se styles include il flag DateTimeStyles.NoCurrentDateDefault. Il parametro style determina se il parametro s può contenere spazi vuoti iniziali, interni o finali.

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

Il parametro format contiene un criterio che corrisponde al formato previsto del parametro s. Il modello nel parametro format è costituito da uno o più identificatori di formato personalizzati della stringhe di formato data e ora personalizzate tabella 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 parametro provider 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".

Nota

Invece di richiedere che tale s sia conforme a un singolo formato per l'esito positivo dell'operazione di analisi, è possibile chiamare il metodo DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) e specificare più formati consentiti. In questo modo è più probabile che l'operazione di analisi abbia esito positivo.

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 parametro provider, come è il formato preciso di s se format è una stringa di identificatore di formato standard. Il parametro provider può essere uno dei seguenti:

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

Il parametro styles 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 metodo TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime).

Membro DateTimeStyles Descrizione
AdjustToUniversal Analizza s e, se necessario, lo converte in formato UTC. Se s include una differenza di fuso orario o se s non contiene informazioni sul fuso orario, ma styles include il flag DateTimeStyles.AssumeLocal, il metodo analizza la stringa, chiama ToUniversalTime per convertire il valore DateTime restituito in UTC e imposta la proprietà Kind 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 DateTimeStyles.AssumeUniversal, il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore DateTime restituito e imposta la proprietà Kind 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 flag di DateTimeStyles.AdjustToUniversal non sia presente, la proprietà Kind del valore DateTime restituito è impostata su DateTimeKind.Local.
AssumeUniversal Specifica che se s non dispone di informazioni sul fuso orario, si presuppone che rappresenti l'ora UTC. A meno che il flag DateTimeStyles.AdjustToUniversal non sia presente, il metodo converte il valore DateTime restituito dall'ora UTC all'ora locale e imposta la relativa proprietà Kind in DateTimeKind.Local.
NoCurrentDateDefault Se s contiene ora senza informazioni sulla data, la data del valore restituito viene impostata su DateTime.MinValue.Date.
None Il parametro s 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 DateTime restituito viene impostata su 1/1/0001. Se s non contiene informazioni sul fuso orario, la proprietà Kind dell'oggetto DateTime restituito viene impostata su DateTimeKind.Unspecified. Se le informazioni sul fuso orario sono presenti in s, l'ora viene convertita nell'ora locale e la proprietà Kind dell'oggetto DateTime restituito viene impostata su DateTimeKind.Local.
RoundtripKind Per le stringhe che contengono informazioni sul fuso orario, tenta di impedire la conversione in un valore DateTime con la relativa proprietà Kind 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 metodo TryParseExact restituisce false se la stringa da analizzare contiene un componente di ora e un designatore AM/PM non in accordo. In .NET Framework 3.5 e versioni precedenti, il designatore AM/PM viene ignorato.

Vedi anche

Si applica a

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Origine:
DateTime.cs
Origine:
DateTime.cs
Origine:
DateTime.cs

Converte la rappresentazione di stringa specificata di una data e un'ora nel relativo 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 a uno dei formati specificati. Il metodo restituisce un valore che indica se la conversione è riuscita.

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

s
String

Stringa contenente una data e un'ora da convertire.

formats
String[]

Matrice di formati consentiti di s.

provider
IFormatProvider

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

style
DateTimeStyles

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

result
DateTime

Quando termina, questo metodo contiene il valore DateTime equivalente alla data e all'ora contenute in s, se la conversione è riuscita o DateTime.MinValue se la conversione non è riuscita. La conversione ha esito negativo se s o formats è null, s o un elemento di formats è una stringa vuota oppure il formato di s non è esattamente come specificato da almeno uno dei modelli di formato in formats. Questo parametro viene passato non inizializzato.

Restituisce

Boolean

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

Eccezioni

ArgumentException

style non è un valore di DateTimeStyles valido.

-o-

style contiene una combinazione non valida di valori di DateTimeStyles , ad esempio AssumeLocal e AssumeUniversal.

Esempio

Nell'esempio seguente viene utilizzato il metodo DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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 metodo DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) analizza la rappresentazione di stringa di una data corrispondente a uno dei modelli assegnati al parametro formats. È come il metodo DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles), ad eccezione del metodo TryParseExact non genera un'eccezione se la conversione non riesce.

Il parametro s contiene la data e l'ora da analizzare. Se il parametro s contiene solo un'ora e nessuna data, la data corrente viene utilizzata a meno che il parametro style non includa il flag DateTimeStyles.NoCurrentDateDefault, nel qual caso viene utilizzata la data predefinita (DateTime.Date.MinValue). Se il parametro s contiene solo una data e nessuna ora, viene usata la mezzanotte (00:00:00). Il parametro style determina inoltre se il parametro s 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 proprietà Kind dell'oggetto DateTime restituito è DateTimeKind.Unspecified. Questo comportamento può essere modificato utilizzando il flag di DateTimeStyles.AssumeLocal, che restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Localoppure utilizzando i flag DateTimeStyles.AssumeUniversal e DateTimeStyles.AdjustToUniversal, che restituisce un valore DateTime la cui proprietà Kind è DateTimeKind.Utc. Se contiene informazioni sul fuso orario, l'ora viene convertita in ora locale, se necessario e la proprietà Kind dell'oggetto DateTime restituito viene impostata su DateTimeKind.Local. Questo comportamento può essere modificato usando il flag DateTimeStyles.RoundtripKind per non convertire l'ora UTC (Coordinated Universal Time) in un'ora locale e impostare la proprietà Kind su DateTimeKind.Utc.

Il parametro formats contiene una matrice di modelli, una delle quali s deve corrispondere esattamente se l'operazione di analisi ha esito positivo. I modelli nel parametro formats sono costituiti da uno o più identificatori di formato personalizzati della stringhe di formato data e ora personalizzate tabella 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 parametro provider 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 parametro provider, come è il formato preciso di s se format è una stringa di identificatore di formato standard. Il parametro provider può essere uno dei seguenti:

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

Il parametro styles 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 metodo TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime).

Membro DateTimeStyles Descrizione
AdjustToUniversal Analizza s e, se necessario, lo converte in formato UTC. Se s include una differenza di fuso orario o se s non contiene informazioni sul fuso orario, ma styles include il flag DateTimeStyles.AssumeLocal, il metodo analizza la stringa, chiama ToUniversalTime per convertire il valore DateTime restituito in UTC e imposta la proprietà Kind 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 DateTimeStyles.AssumeUniversal, il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore DateTime restituito e imposta la proprietà Kind 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 flag di DateTimeStyles.AdjustToUniversal non sia presente, la proprietà Kind del valore DateTime restituito è impostata su DateTimeKind.Local.
AssumeUniversal Specifica che se s non dispone di informazioni sul fuso orario, si presuppone che rappresenti l'ora UTC. A meno che il flag DateTimeStyles.AdjustToUniversal non sia presente, il metodo converte il valore DateTime restituito dall'ora UTC all'ora locale e imposta la relativa proprietà Kind in DateTimeKind.Local.
NoCurrentDateDefault Se s contiene ora senza informazioni sulla data, la data del valore restituito viene impostata su DateTime.MinValue.Date.
None Il parametro s 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 DateTime restituito viene impostata su 1/1/0001. Se s non contiene informazioni sul fuso orario, la proprietà Kind dell'oggetto DateTime restituito viene impostata su DateTimeKind.Unspecified. Se le informazioni sul fuso orario sono presenti in s, l'ora viene convertita nell'ora locale e la proprietà Kind dell'oggetto DateTime restituito viene impostata su DateTimeKind.Local.
RoundtripKind Per le stringhe che contengono informazioni sul fuso orario, tenta di impedire la conversione in un valore DateTime con la relativa proprietà Kind 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 metodo TryParseExact restituisce false se la stringa da analizzare contiene un componente di ora e un designatore AM/PM non in accordo. In .NET Framework 3.5 e versioni precedenti, il designatore AM/PM viene ignorato.

Vedi anche

Si applica a