DateTime.TryParse Metodo

Definizione

Spazio dei nomi:: System

Assembly:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Converte la rappresentazione di stringa specificata di una data e dell'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è riuscita.

Overload

Nome	Descrizione
TryParse(ReadOnlySpan<Char>, DateTime)	Converte l'intervallo di caratteri specificato di una data e un'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è riuscita.
TryParse(String, DateTime)	Converte la rappresentazione di stringa specificata di una data e dell'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è riuscita.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Tenta di analizzare un intervallo di caratteri in un valore.
TryParse(String, IFormatProvider, DateTime)	Tenta di analizzare una stringa in un valore.
TryParse(String, IFormatProvider, DateTimeStyles, DateTime)	Converte la rappresentazione di stringa specificata di una data e dell'ora nell'equivalente DateTime utilizzando le informazioni sul formato e lo stile di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione è riuscita.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Converte la rappresentazione dell'intervallo di una data e dell'ora nell'equivalente DateTime utilizzando le informazioni sul formato e lo stile di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione ha avuto esito positivo.

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 in 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à per il cambiamento dell'era, vedere Preparare l'applicazione per il cambiamento 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.

TryParse(ReadOnlySpan<Char>, DateTime)

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

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

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParse(ReadOnlySpan<char> s, out DateTime result);

static member TryParse : ReadOnlySpan<char> * DateTime -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As DateTime) As Boolean

Parametri

s: ReadOnlySpan<Char>

Stringa contenente una data e un'ora da convertire.

result: DateTime

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

Valori restituiti

Boolean

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

Si applica a

TryParse(String, DateTime)

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Converte la rappresentazione di stringa specificata di una data e dell'ora nell'equivalente DateTime e restituisce un valore che indica se la conversione è riuscita.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] DateTime % result);

public static bool TryParse(string s, out DateTime result);

public static bool TryParse(string? s, out DateTime result);

static member TryParse : string * DateTime -> bool

Public Shared Function TryParse (s As String, ByRef result As DateTime) As Boolean

Parametri

s: String

Stringa contenente una data e un'ora da convertire.

result: DateTime

Valori restituiti

Boolean

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

Esempio

Nell'esempio seguente viene passato un numero di stringhe di data e ora al DateTime.TryParse(String, DateTime) metodo .

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"05/01/2009 14:57:32.8", "2009-05-01 14:57:32.8",
                              "2009-05-01T14:57:32.8375298-04:00", "5/01/2008",
                              "5/01/2008 14:57:32.80 -07:00",
                              "1 May 2008 2:57:32.8 PM", "16-05-2009 1:00:32 PM",
                              "Fri, 15 May 2009 20:10:57 GMT" };
      DateTime dateValue;

      Console.WriteLine("Attempting to parse strings using {0} culture.",
                        CultureInfo.CurrentCulture.Name);
      foreach (string dateString in dateStrings)
      {
         if (DateTime.TryParse(dateString, out dateValue))
            Console.WriteLine("  Converted '{0}' to {1} ({2}).", dateString,
                              dateValue, dateValue.Kind);
         else
            Console.WriteLine("  Unable to parse '{0}'.", dateString);
      }
   }
}
// The example displays output like the following:
//    Attempting to parse strings using en-US culture.
//      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
//
//      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
//      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
//      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
//      Unable to parse '16-05-2009 1:00:32 PM'.
//      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

open System
open System.Globalization

let dateStrings = 
    [ "05/01/2009 14:57:32.8"; "2009-05-01 14:57:32.8"
      "2009-05-01T14:57:32.8375298-04:00"; "5/01/2008"
      "5/01/2008 14:57:32.80 -07:00"
      "1 May 2008 2:57:32.8 PM"; "16-05-2009 1:00:32 PM"
      "Fri, 15 May 2009 20:10:57 GMT" ]

printfn $"Attempting to parse strings using {CultureInfo.CurrentCulture.Name} culture."
for dateString in dateStrings do
    match DateTime.TryParse dateString with
    | true, dateValue ->
        printfn $"  Converted '{dateString}' to {dateValue} ({dateValue.Kind})."
    | _ ->
        printfn $"  Unable to parse '{dateString}'."


// The example displays output like the following:
//    Attempting to parse strings using en-US culture.
//      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
//      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
//      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
//      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
//      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
//      Unable to parse '16-05-2009 1:00:32 PM'.
//      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"05/01/2009 14:57:32.8", "2009-05-01 14:57:32.8",
                                     "2009-05-01T14:57:32.8375298-04:00", "5/01/2008",
                                     "5/01/2008 14:57:32.80 -07:00",
                                     "1 May 2008 2:57:32.8 PM", "16-05-2009 1:00:32 PM",
                                     "Fri, 15 May 2009 20:10:57 GMT"}
      Dim dateValue As Date
      
      Console.WriteLine("Attempting to parse strings using {0} culture.", _
                        CultureInfo.CurrentCulture.Name)
      For Each dateString As String In dateStrings
         If Date.TryParse(dateString, dateValue) Then
            Console.WriteLine("  Converted '{0}' to {1} ({2}).", dateString, _
                              dateValue, dateValue.Kind)
         Else
            Console.WriteLine("  Unable to parse '{0}'.", dateString)
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'    Attempting to parse strings using en-US culture.
'      Converted '05/01/2009 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
'      Converted '2009-05-01 14:57:32.8' to 5/1/2009 2:57:32 PM (Unspecified).
'      Converted '2009-05-01T14:57:32.8375298-04:00' to 5/1/2009 11:57:32 AM (Local).
'
'      Converted '5/01/2008' to 5/1/2008 12:00:00 AM (Unspecified).
'      Converted '5/01/2008 14:57:32.80 -07:00' to 5/1/2008 2:57:32 PM (Local).
'      Converted '1 May 2008 2:57:32.8 PM' to 5/1/2008 2:57:32 PM (Unspecified).
'      Unable to parse '16-05-2009 1:00:32 PM'.
'      Converted 'Fri, 15 May 2009 20:10:57 GMT' to 5/15/2009 1:10:57 PM (Local).

Commenti

Il DateTime.TryParse(String, DateTime) metodo è simile al metodo , ad eccezione del DateTime.Parse(String) fatto che il TryParse(String, DateTime) metodo non genera un'eccezione se la conversione non riesce.

La stringa s viene analizzata usando le informazioni di formattazione nell'oggetto corrente DateTimeFormatInfo , fornito in modo implicito dalle impostazioni cultura correnti.

Questo metodo tenta di ignorare i dati non riconosciuti, se possibile, e inserisce informazioni mancanti su mese, giorno e anno mancanti con la data corrente. Se s contiene solo una data e nessuna ora, questo metodo presuppone che l'ora sia 12:00 mezzanotte. Se s include un componente di data con un anno a due cifre, viene convertito in un anno nel calendario corrente delle impostazioni cultura correnti in base al valore della Calendar.TwoDigitYearMax proprietà . Qualsiasi carattere di spazio vuoto iniziale, interno o finale in s viene ignorato. La data e l'ora possono essere racchiuse tra parentesi con una coppia di caratteri NUMERO iniziale e finale ('#', U+0023) e possono essere terminati con uno o più caratteri NULL (U+0000).

Poiché il DateTime.TryParse(String, DateTime) metodo tenta di analizzare la rappresentazione di stringa di una data e di un'ora usando le regole di formattazione delle impostazioni cultura correnti, il tentativo di analizzare una determinata stringa tra impostazioni cultura diverse può avere esito negativo o restituire risultati diversi. Se un formato di data e ora specifico verrà analizzato tra impostazioni locali diverse, usare il DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodo o uno degli overload del TryParseExact metodo e fornire un identificatore di formato.

Se s è la rappresentazione di stringa di un giorno bisestile in un anno bisestile nel calendario corrente, il metodo analizza s correttamente. Se s è la rappresentazione di stringa di un giorno bisestile in un anno non bisestile nel calendario corrente delle impostazioni cultura correnti, l'operazione di analisi ha esito negativo e il metodo restituisce false.

Se s non contiene informazioni sul fuso orario, result contiene un DateTime valore la cui Kind proprietà è DateTimeKind.Unspecified quando il metodo restituisce. Se la stringa da analizzare contiene informazioni sul fuso orario, result contiene un DateTime valore la cui Kind proprietà è DateTimeKind.Local quando il metodo restituisce.

Note per i chiamanti

La formattazione è influenzata dalle proprietà dell'oggetto corrente DateTimeFormatInfo , che per impostazione predefinita derivano dall'elemento Opzioni internazionali e della lingua nel Pannello di controllo. Il TryParse metodo può avere esito negativo e restituire False in modo imprevisto se le proprietà e DateSeparator correnti TimeSeparator sono impostate sullo stesso valore.

Vedi anche

Si applica a

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Tenta di analizzare un intervallo di caratteri in un valore.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] DateTime % result) = ISpanParsable<DateTime>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out DateTime result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * DateTime -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As DateTime) As Boolean

Parametri

s: ReadOnlySpan<Char>

Intervallo di caratteri da analizzare.

provider: IFormatProvider

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

result: DateTime

Quando termina, questo metodo contiene il risultato dell'analisi scorretta di o di un valore non definito in caso di errore.

Valori restituiti

Boolean

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

Si applica a

TryParse(String, IFormatProvider, DateTime)

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Tenta di analizzare una stringa in un valore.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] DateTime % result) = IParsable<DateTime>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out DateTime result);

static member TryParse : string * IFormatProvider * DateTime -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As DateTime) As Boolean

Parametri

s: String

Stringa da analizzare.

provider: IFormatProvider

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

result: DateTime

Quando termina, questo metodo contiene il risultato dell'analisi s corretta o di un valore non definito in caso di errore.

Valori restituiti

Boolean

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

Si applica a

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Converte la rappresentazione di stringa specificata di una data e dell'ora nell'equivalente DateTime utilizzando le informazioni sul formato e lo stile di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione è riuscita.

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

public static bool TryParse(string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles, out DateTime result);

public static bool TryParse(string? s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles, out DateTime result);

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

Public Shared Function TryParse (s As String, provider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametri

s: String

Stringa contenente una data e un'ora da convertire.

provider: IFormatProvider

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

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

Valori restituiti

Boolean

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

Eccezioni

ArgumentException

styles non è un valore valido DateTimeStyles .

oppure

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

NotSupportedException

provider è una cultura neutra e non può essere usata in un'operazione di analisi.

Esempio

Nell'esempio seguente viene illustrato il DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodo .

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString;
      CultureInfo culture;
      DateTimeStyles styles;
      DateTime dateResult;

      // Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM";
      culture = CultureInfo.CreateSpecificCulture("en-US");
      styles = DateTimeStyles.None;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.",
                           dateString);

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Parse a date and time that is assumed to be local.
      // This time is five hours behind UTC. The local system's time zone is
      // eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00";
      styles = DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);

      // Assume a date and time string formatted for the fr-FR culture is the local
      // time and convert it to UTC.
      dateString = "2008-03-01 10:00";
      culture = CultureInfo.CreateSpecificCulture("fr-FR");
      styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal;
      if (DateTime.TryParse(dateString, culture, styles, out dateResult))
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, dateResult, dateResult.Kind);
      else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
   }
}
// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Parse a date and time with no styles.
    let dateString = "03/01/2009 10:00 AM"
    let culture = CultureInfo.CreateSpecificCulture "en-US"
    let styles = DateTimeStyles.None
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ -> 
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}." 
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Parse a date and time that is assumed to be local.
    // This time is five hours behind UTC. The local system's time zone is
    // eight hours behind UTC.
    let dateString = "2009/03/01T10:00:00-5:00"
    let styles = DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}."
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    // Assume a date and time string formatted for the fr-FR culture is the local
    // time and convert it to UTC.
    let dateString = "2008-03-01 10:00"
    let culture = CultureInfo.CreateSpecificCulture "fr-FR"
    let styles = DateTimeStyles.AdjustToUniversal ||| DateTimeStyles.AssumeLocal
    match DateTime.TryParse(dateString, culture, styles) with
    | true, dateResult ->
        printfn $"{dateString} converted to {dateResult} {dateResult.Kind}." 
    | _ ->
        printfn $"Unable to convert {dateString} to a date and time."

    0

// The example displays the following output to the console:
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
//       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
//       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
//       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
//       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateString As String
      Dim culture As CultureInfo
      Dim styles As DateTimeStyles 
      Dim dateResult As DateTime
      
      ' Parse a date and time with no styles.
      dateString = "03/01/2009 10:00 AM"
      culture = CultureInfo.CreateSpecificCulture("en-US")
      styles = DateTimeStyles.None
      If DateTime.TryParse(dateString, culture, styles, dateResult) Then
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Parse a date and time that is assumed to be local.
      ' This time is five hours behind UTC. The local system's time zone is 
      ' eight hours behind UTC.
      dateString = "2009/03/01T10:00:00-5:00"
      styles = DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
      
      ' Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00"
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      

      ' Assume a date and time string formatted for the fr-FR culture is the local 
      ' time and convert it to UTC.
      dateString = "2008-03-01 10:00"
      culture = CultureInfo.CreateSpecificCulture("fr-FR")
      styles = DateTimeStyles.AdjustToUniversal Or DateTimeStyles.AssumeLocal
      If DateTime.TryParse(dateString, culture, styles, dateResult)
         Console.WriteLine("{0} converted to {1} {2}.", _
                           dateString, dateResult, dateResult.Kind)
      Else
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString)
      End If      
   End Sub
End Module
' The example displays the following output to the console:
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Unspecified.
'       03/01/2009 10:00 AM converted to 3/1/2009 10:00:00 AM Local.
'       2009/03/01T10:00:00-5:00 converted to 3/1/2009 7:00:00 AM Local.
'       Unable to convert 03/01/2009T10:00:00-5:00 to a date and time.
'       2008-03-01 10:00 converted to 3/1/2008 6:00:00 PM Utc.

Commenti

Il DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodo analizza una stringa che può contenere informazioni su data, ora e fuso orario. È simile al metodo DateTime.Parse(String, IFormatProvider, DateTimeStyles), ad eccezione del fatto che il metodo DateTime.TryParse(String, DateTime) non lancia un'eccezione se la conversione non riesce.

Questo metodo tenta di ignorare i dati non riconosciuti e analizzare completamente la stringa di input (s). Se s contiene un'ora ma nessuna data, il metodo sostituisce per impostazione predefinita la data corrente o, se styles include il NoCurrentDateDefault flag, sostituisce DateTime.Date.MinValue. Se s contiene una data ma nessuna ora, la mezzanotte 12:00 viene usata come ora predefinita. Se una data è presente ma il relativo componente year è costituito da solo due cifre, viene convertito in un anno nel provider calendario corrente del parametro in base al valore della Calendar.TwoDigitYearMax proprietà. Tutti gli spazi vuoti iniziali, interni o finali in s vengono ignorati. La data e l'ora possono essere racchiuse tra parentesi con una coppia di caratteri NUMERO iniziale e finale ('#', U+0023) e possono essere terminati con uno o più caratteri NULL (U+0000).

Formati validi specifici per gli elementi di data e ora, nonché per i nomi e i simboli usati in date e ore, sono definiti dal provider parametro , che può essere uno dei seguenti:

Oggetto CultureInfo che rappresenta la cultura la cui formattazione viene utilizzata nel parametro s. L'oggetto DateTimeFormatInfo restituito dalla CultureInfo.DateTimeFormat proprietà definisce la formattazione utilizzata in s.
Oggetto DateTimeFormatInfo che definisce la formattazione utilizzata in s.
Implementazione personalizzata IFormatProvider . Il IFormatProvider.GetFormat metodo restituisce un DateTimeFormatInfo oggetto che definisce la formattazione utilizzata in s.

Se provider è null, viene utilizzata l'impostazione cultura corrente.

Se s è la rappresentazione di stringa di un giorno bisestile in un anno bisestile nel calendario corrente, il metodo analizza s correttamente. Se s è la rappresentazione di stringa di un giorno bisestile in un anno non bisestile nel calendario corrente di provider, l'operazione di analisi ha esito negativo e il metodo restituisce false.

Il styles parametro definisce l'interpretazione precisa della stringa analizzata e la modalità di gestione dell'operazione di analisi. Può essere uno o più membri dell'enumerazione DateTimeStyles , come descritto nella tabella seguente.

Membro DateTimeStyles	Description
AdjustToUniversal	Analizza e, se necessario, lo converte `s` in formato UTC. Se `s` include una differenza di fuso orario o se `s` non contiene informazioni sul fuso orario ma `styles` include il DateTimeStyles.AssumeLocal flag , il metodo analizza la stringa, chiama ToUniversalTime per convertire il valore restituito DateTime in utc e imposta la Kind proprietà su DateTimeKind.Utc. Se `s` indica che rappresenta l'ora UTC o se `s` non contiene informazioni sul fuso orario ma `styles` include il DateTimeStyles.AssumeUniversal flag , il metodo analizza la stringa, non esegue alcuna conversione del fuso orario sul valore restituito DateTime e imposta la Kind proprietà su DateTimeKind.Utc. In tutti gli altri casi, la bandiera non ha alcun effetto.
AllowInnerWhite	Anche se valido, questo valore viene ignorato. Gli spazi vuoti interni sono consentiti negli elementi di data e ora di `s`.
AllowLeadingWhite	Anche se valido, questo valore viene ignorato. Gli spazi vuoti iniziali sono consentiti negli elementi di data e ora di `s`.
AllowTrailingWhite	Anche se valido, questo valore viene ignorato. Gli spazi vuoti finali sono consentiti negli elementi di data e ora di `s`.
AllowWhiteSpaces	Specifica che `s` può contenere spazi vuoti iniziali, interni e finali. Si tratta del comportamento predefinito. Non può essere sovrascritto fornendo un valore di enumerazione più restrittivo come DateTimeStyles, ad esempio DateTimeStyles.None.
AssumeLocal	Specifica che, se `s` non dispone di informazioni sul fuso orario, si presuppone che rappresenti un'ora locale. A meno che il DateTimeStyles.AdjustToUniversal indicatore non sia presente, la proprietà Kind del valore restituito viene impostata su DateTime.
AssumeUniversal	Specifica che, se `s` non dispone di informazioni sul fuso orario, si presuppone che rappresenti l'ora UTC. A meno che il DateTimeStyles.AdjustToUniversal flag non sia presente, il metodo converte il valore restituito DateTime dall'ora UTC all'ora locale e imposta la relativa Kind proprietà su DateTimeKind.Local.
None	Anche se valido, questo valore viene ignorato.
RoundtripKind	Per le stringhe che contengono informazioni sul fuso orario, tenta di impedire la conversione di una stringa di data e ora in un DateTime valore con la relativa Kind proprietà impostata su DateTimeKind.Local. In genere, tale stringa viene creata chiamando il DateTime.ToString(String) metodo usando gli identificatori di formato standard "o", "r" o "u".

Se s non contiene informazioni sul fuso orario, il DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodo restituisce un DateTime valore la cui Kind proprietà è DateTimeKind.Unspecified a meno che un styles flag non indichi diversamente. Se s include informazioni sul fuso orario o sulla differenza di fuso orario, il DateTime.TryParse(String, IFormatProvider, DateTimeStyles, DateTime) metodo esegue una conversione dell'ora necessaria e restituisce uno dei seguenti elementi:

Valore DateTime la cui data e ora riflettono l'ora locale e la cui Kind proprietà è DateTimeKind.Local.
In alternativa, se styles include il flag AdjustToUniversal, un valore DateTime la cui data e ora riflettono l'ora UTC e la cui proprietà Kind è DateTimeKind.Utc.

Questo comportamento può essere sottoposto a override usando il DateTimeStyles.RoundtripKind flag .

Analizzare le impostazioni culture personalizzate

Se si analizza una stringa di data e ora generata per impostazioni cultura personalizzate, usare il TryParseExact metodo anziché il TryParse metodo per migliorare la probabilità che l'operazione di analisi abbia esito positivo. Una stringa di data e ora di una cultura personalizzata può essere complessa e difficile da interpretare. Il TryParse metodo tenta di analizzare una stringa con diversi modelli di analisi impliciti, che potrebbero non riuscire. Al contrario, il TryParseExact metodo richiede di designare in modo esplicito uno o più modelli di analisi esatti che potrebbero avere esito positivo.

Per ulteriori informazioni sulle culture personalizzate, vedere la classe System.Globalization.CultureAndRegionInfoBuilder.

Note per i chiamanti

La formattazione è influenzata dalle proprietà dell'oggetto corrente DateTimeFormatInfo , fornito dal provider parametro . Il TryParse metodo può avere esito negativo e restituire False in modo imprevisto se le proprietà e DateSeparator correnti TimeSeparator sono impostate sullo stesso valore.

Vedi anche

Si applica a

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

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Origine:: DateTime.cs

Converte la rappresentazione dell'intervallo di una data e dell'ora nell'equivalente DateTime utilizzando le informazioni sul formato e lo stile di formattazione specifiche delle impostazioni cultura specificate e restituisce un valore che indica se la conversione ha avuto esito positivo.

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

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

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

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTime) As Boolean

Parametri

s: ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano la data e l'ora da convertire.

provider: IFormatProvider

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

styles: DateTimeStyles

result: DateTime

Valori restituiti

Boolean

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

Si applica a

Commenti e suggerimenti

Questa pagina è stata utile?