DateTime.TryParseExact Metodo

Definizione

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'equivalente DateTime. Il formato della rappresentazione di stringa deve corrispondere esattamente a un formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

Overload

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

Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

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

Converte l'intervallo di caratteri specificato di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente.

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

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

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

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

Commenti

Importante

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

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

Converte una determinata rappresentazione in forma di intervallo di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

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 necessario di s.

provider
IFormatProvider

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

style
DateTimeStyles

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

result
DateTime

Quando questo metodo restituisce, contiene il DateTime valore equivalente alla data e all'ora contenuta in s, se la conversione ha avuto esito positivo o DateTime.MinValue se la conversione non è riuscita. La conversione non riesce se il parametro s o il parametro format è null, è una stringa vuota o non contiene un valore di data e ora corrispondente al criterio specificato nel parametro format. Questo parametro viene passato non inizializzato.

Restituisce

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

Si applica a

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

Converte l'intervallo di caratteri specificato di una data e di un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è stata eseguita correttamente.

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 relativamente a s.

style
DateTimeStyles

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

result
DateTime

Quando questo metodo restituisce, contiene il DateTime valore equivalente alla data e all'ora contenuta in s, se la conversione ha avuto esito positivo o DateTime.MinValue se la conversione non è riuscita. La conversione ha esito negativo se il parametro s è null, è Empty o non contiene una rappresentazione di data e ora in formato di stringa valida. Questo parametro viene passato non inizializzato.

Restituisce

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

Si applica a

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

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

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 data e ora da convertire.

format
String

Formato necessario di s.

provider
IFormatProvider

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

style
DateTimeStyles

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

result
DateTime

Quando questo metodo restituisce, contiene il DateTime valore equivalente alla data e all'ora contenuta in s, se la conversione ha avuto esito positivo o DateTime.MinValue se la conversione non è riuscita. La conversione non riesce se il parametro s o il parametro format è null, è una stringa vuota o non contiene un valore di data e ora corrispondente al criterio specificato nel parametro format. Questo parametro viene passato non inizializzato.

Restituisce

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

Eccezioni

styles non è un valore valido di DateTimeStyles.

-oppure-

styles contiene una combinazione non valida di valori di DateTimeStyles, ad esempio sia AssumeLocal che AssumeUniversal.

Esempio

Nell'esempio seguente viene illustrato il DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metodo. Si noti che la stringa "5/01/2009 8:30 AM" non può essere analizzata correttamente quando il parametro è uguale perché gli styles spazi iniziali non sono consentiti DateTimeStyles.None da format. Inoltre, la stringa "5/01/2009 09:00" non può essere analizzata correttamente con un valore "MM/dd/yhh:mm" perché la stringa di data non precede il numero di mese con zero format 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 stringa di una data, che deve essere nel formato definito dal format parametro. È simile al DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metodo, ad eccezione del fatto che il TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metodo non genera un'eccezione se la conversione ha esito negativo.

Il s parametro contiene la data e l'ora format da analizzare e deve essere in un formato definito dal parametro. Se gli elementi 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 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 elemento date e l'operazione di analisi ha esito positivo, il valore risultante DateTime per impostazione predefinita ha una data di o ha una data di DateTime.Now.DateDateTime.MinValue.Date se styles include il DateTimeStyles.NoCurrentDateDefault flag. Il style parametro determina se il s parametro può contenere caratteri di 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 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 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 format parametro contiene un modello 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 di formato data e ora standard.

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

Nota

Anziché richiedere che sia s conforme a un singolo formato per l'operazione di analisi con esito positivo, è possibile chiamare il DateTime.TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metodo e specificare più formati consentiti. Ciò rende 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 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:

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

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

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

Vedi anche

Si applica a

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

Converte una determinata rappresentazione di stringa di una data e di un'ora nell'oggetto DateTime equivalente usando la matrice di formati, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente ad almeno uno dei formati specificati. Il metodo restituisce un valore che indica se la conversione è stata eseguita correttamente.

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 che contiene una data e un'ora da convertire.

formats
String[]

Matrice di formati consentiti di s.

provider
IFormatProvider

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

style
DateTimeStyles

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

result
DateTime

Quando questo metodo restituisce, contiene il DateTime valore equivalente alla data e all'ora contenuta in s, se la conversione ha avuto esito positivo o DateTime.MinValue se la conversione non è riuscita. La conversione non riesce se il parametro s o il parametro formats è null, il parametro s o un elemento del parametro formats è una stringa vuota o il formato di s non è uguale a quello specificato da almeno uno dei modelli di formato indicati nel parametro formats. Questo parametro viene passato non inizializzato.

Restituisce

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

Eccezioni

styles non è un valore valido di DateTimeStyles.

-oppure-

styles contiene una combinazione non valida di valori di DateTimeStyles, ad esempio sia AssumeLocal che AssumeUniversal.

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 stringa di una data corrispondente a uno dei modelli assegnati al formats parametro. È simile al metodo, ad eccezione del TryParseExact metodo non genera un'eccezione DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) se la conversione ha esito negativo.

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

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:

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

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

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

Vedi anche

Si applica a