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 sul test delle applicazioni nei sistemi Windows per garantire la conformità per il cambiamento di era, vedere Preparare l'applicazione per la modifica dell'era giapponese. Per le funzionalità in .NET che supportano calendari con più ere e per le procedure consigliate quando si lavora con calendari che supportano più ere, vedere Uso delle ere.

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 viene restituito, contiene il valore DateTime equivalente alla data e all'ora contenute nel parametro s, se la conversione riesce; in caso contrario, viene restituito MinValue. 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

Boolean

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 viene restituito, contiene il valore DateTime equivalente alla data e all'ora contenute nel parametro s, se la conversione riesce; in caso contrario, viene restituito MinValue. 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

Boolean

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 viene restituito, contiene il valore DateTime equivalente alla data e all'ora contenute nel parametro s, se la conversione riesce; in caso contrario, viene restituito MinValue. 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

Boolean

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 a perché gli spazi iniziali non sono consentiti da styles DateTimeStyles.None format . Inoltre, la stringa "5/01/2009 09:00" non può essere analizzata correttamente con format "MM/gg/aahh: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).
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 , ad eccezione del fatto che il DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metodo non genera 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 parametro format . Se gli elementi di data, ora e fuso orario sono presenti in , devono essere s visualizzati anche nell'ordine specificato da format . Se definisce una data senza elemento time e l'operazione di analisi ha esito positivo, il valore risultante ha un'ora di mezzanotte format DateTime (00:00:00). Se definisce un'ora senza elemento date e l'operazione di analisi ha esito positivo, il valore risultante per impostazione predefinita ha una data pari a oppure ha una data di se include format DateTime il flag DateTime.Now.Date DateTime.MinValue.Date styles DateTimeStyles.NoCurrentDateDefault . Il style parametro determina se il parametro può s 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 usando il flag , che restituisce un valore la cui proprietà è oppure i flag e , che restituisce un valore la cui DateTimeStyles.AssumeLocal DateTime proprietà è Kind DateTimeKind.Local DateTimeStyles.AssumeUniversal DateTimeStyles.AdjustToUniversal DateTime Kind DateTimeKind.Utc . Se s contiene informazioni sul fuso orario, l'ora viene convertita nell'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 per non convertire Coordinated Universal Time (UTC) in un'ora locale e impostare DateTimeStyles.RoundtripKind Kind la proprietà su DateTimeKind.Utc .

Il format parametro contiene un modello che corrisponde al formato previsto del s parametro. Il modello nel parametro è costituito da uno o più identificatori di formato personalizzati della tabella Stringhe di formato di data e ora personalizzate o da un singolo identificatore di formato standard, che identifica un modello predefinito, dalla tabella Stringhe di formato di data e ora format standard.

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

Nota

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

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

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

Il parametro include uno o più membri dell'enumerazione che determinano se e dove possono essere presenti spazi vuoti non definiti da e che controllano il comportamento preciso styles DateTimeStyles format dell'operazione di s analisi. Nella tabella seguente viene descritto in che modo ogni membro DateTimeStyles dell'enumerazione influisce sul funzionamento del TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) metodo .

Membro DateTimeStyles Descrizione
AdjustToUniversal Analizza s e, se necessario, lo converte in formato UTC. Se include una differenza di fuso orario o se non contiene informazioni sul fuso orario ma include il flag , il metodo analizza la stringa, chiama per convertire il valore restituito in UTC e imposta la proprietà s s su styles DateTimeStyles.AssumeLocal ToUniversalTime DateTime Kind DateTimeKind.Utc . Se indica che rappresenta l'ora UTC o se non contiene informazioni sul fuso orario ma include il flag , il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore restituito e imposta la proprietà s s su styles DateTimeStyles.AssumeUniversal DateTime Kind DateTimeKind.Utc . In tutti gli altri casi, il flag non ha alcun effetto.
AllowInnerWhite Specifica che gli spazi vuoti non definiti da possono essere format 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 può s contenere spazi iniziali, interni e finali non definiti da format .
AssumeLocal Specifica che se non s dispone di informazioni sul fuso orario, si presuppone che rappresenti un'ora locale. A meno DateTimeStyles.AdjustToUniversal che non sia presente il flag , la proprietà del valore Kind DateTime restituito viene impostata su DateTimeKind.Local .
AssumeUniversal Specifica che se non s sono presenti informazioni sul fuso orario, si presuppone che rappresenti l'ora UTC. A meno che non sia presente il flag , il DateTimeStyles.AdjustToUniversal metodo converte il valore restituito dall'ora UTC all'ora locale DateTime e imposta la relativa proprietà su Kind DateTimeKind.Local .
NoCurrentDateDefault Se s contiene l'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 non dispone di un componente 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 , l'ora viene convertita nell'ora locale e s la Kind proprietà 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 con DateTime la Kind relativa proprietà impostata su DateTimeKind.Local . Questo flag impedisce principalmente la conversione delle ore UTC in ora locale.

Note per i chiamanti

Nell'.NET Framework 4, il metodo restituisce se la stringa da analizzare contiene un componente dell'ora e un designatore TryParseExact false AM/PM non in accordo. Nella versione .NET Framework 3.5 e versioni precedenti, l'designazione AM/PM viene ignorata.

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 viene restituito, contiene il valore DateTime equivalente alla data e all'ora contenute nel parametro s, se la conversione riesce; in caso contrario, viene restituito MinValue. 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

Boolean

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 utilizzato il metodo per garantire che una stringa in diversi DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime) 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.
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 che corrisponde a uno dei modelli assegnati al parametro formats . È simile al metodo DateTime.ParseExact(String, String[], IFormatProvider, DateTimeStyles) , ad eccezione del fatto che il metodo non genera TryParseExact 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 e nessuna data, viene usata la data corrente, a meno che il parametro non includa il flag , nel qual caso viene usata la data predefinita s style ( DateTimeStyles.NoCurrentDateDefault DateTime.Date.MinValue ). Se il parametro contiene solo una data e nessuna ora, viene usata la mezzanotte s (00:00:00). Il parametro determina anche se il parametro può contenere spazi vuoti iniziali, interni o finali diversi da quelli consentiti da una style delle stringhe di formato in s formats .

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

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

Se non si usano separatori di data o ora in un modello di formato personalizzato, usare le impostazioni cultura invarianti per il parametro e la forma più ampia di ogni identificatore di formato provider personalizzato. Ad esempio, se si desidera specificare le 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 sono definiti dal parametro , così come il formato preciso di se è una stringa identificatore di formato s provider s format standard. Il provider parametro può essere uno dei seguenti:

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

Il parametro include uno o più membri dell'enumerazione che determinano se e dove possono essere presenti spazi vuoti non definiti da e che controllano il comportamento preciso styles DateTimeStyles format dell'operazione di s analisi. Nella tabella seguente viene descritto in che modo ogni membro DateTimeStyles dell'enumerazione influisce sul funzionamento del TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) metodo .

Membro DateTimeStyles Descrizione
AdjustToUniversal Analizza s e, se necessario, lo converte in formato UTC. Se include una differenza di fuso orario o se non contiene informazioni sul fuso orario ma include il flag , il metodo analizza la stringa, chiama per convertire il valore restituito in UTC e imposta la proprietà s s su styles DateTimeStyles.AssumeLocal ToUniversalTime DateTime Kind DateTimeKind.Utc . Se indica che rappresenta l'ora UTC o se non contiene informazioni sul fuso orario ma include il flag , il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore restituito e imposta la proprietà s s su styles DateTimeStyles.AssumeUniversal DateTime Kind DateTimeKind.Utc . In tutti gli altri casi, il flag non ha alcun effetto.
AllowInnerWhite Specifica che gli spazi vuoti non definiti da possono essere format 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 può s contenere spazi iniziali, interni e finali non definiti da format .
AssumeLocal Specifica che se non s dispone di informazioni sul fuso orario, si presuppone che rappresenti un'ora locale. A meno DateTimeStyles.AdjustToUniversal che non sia presente il flag , la proprietà del valore Kind DateTime restituito viene impostata su DateTimeKind.Local .
AssumeUniversal Specifica che se non s sono presenti informazioni sul fuso orario, si presuppone che rappresenti l'ora UTC. A meno che non sia presente il flag , il DateTimeStyles.AdjustToUniversal metodo converte il valore restituito dall'ora UTC all'ora locale DateTime e imposta la relativa proprietà su Kind DateTimeKind.Local .
NoCurrentDateDefault Se s contiene l'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 non dispone di un componente 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 , l'ora viene convertita nell'ora locale e s la Kind proprietà 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 con DateTime la Kind relativa proprietà impostata su DateTimeKind.Local . Questo flag impedisce principalmente la conversione delle ore UTC in ora locale.

Note per i chiamanti

Nell'.NET Framework 4, il metodo restituisce se la stringa da analizzare contiene un componente dell'ora e un designatore TryParseExact false AM/PM non in accordo. Nella versione .NET Framework 3.5 e versioni precedenti, l'designazione AM/PM viene ignorata.

Vedi anche

Si applica a