Compartilhar via

DateTimeOffset.TryParseExact Método

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Converte a representação de cadeia de caracteres especificada de uma data e hora em seu DateTimeOffset equivalente. O formato da representação de cadeia de caracteres deve corresponder exatamente a um formato especificado.

Sobrecargas

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

Converte a representação de cadeia de caracteres especificada de uma data e hora em seu DateTimeOffset equivalente usando a matriz especificada de formatos, informações de formato específicas da cultura e estilo. O formato da representação de cadeia de caracteres deve corresponder exatamente a um dos formatos especificados.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTimeOffset)

Converte a representação de uma data e hora em um intervalo de caracteres em seu DateTimeOffset equivalente usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato da representação de data e hora deve corresponder exatamente ao formato especificado.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Converte a representação de uma data e hora em um intervalo de caracteres em seu DateTimeOffset equivalente usando os formatos especificados, as informações de formato específicas da cultura e o estilo. O formato da representação de data e hora deve corresponder exatamente a um dos formatos especificados.
TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Converte a representação de cadeia de caracteres especificada de uma data e hora em seu DateTimeOffset equivalente usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato da representação de cadeia de caracteres deve corresponder exatamente ao formato especificado.

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

Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs

Converte a representação de cadeia de caracteres especificada de uma data e hora em seu DateTimeOffset equivalente usando a matriz especificada de formatos, informações de formato específicas da cultura e estilo. O formato da representação de cadeia de caracteres deve corresponder exatamente a um dos formatos especificados.

public:
 static bool TryParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parâmetros

input
String

Uma cadeia de caracteres que contém uma data e hora a serem convertidas.

formats
String[]

Uma matriz que define os formatos esperados de input.

formatProvider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre input.

styles
DateTimeStyles

Uma combinação bit a bit de valores de enumeração que indica o formato permitido de entrada. Um valor típico a ser especificado é None.

result
DateTimeOffset

Quando o método é retornado, contém o DateTimeOffset equivalente à data e hora de input, se a conversão foi bem-sucedida ou DateTimeOffset.MinValue, se a conversão falhou. A conversão falhará se o input não contiver uma representação de cadeia de caracteres válida de uma data e hora ou não contiver a data e a hora no formato esperado definido por formatsou se formats for null. Esse parâmetro é passado sem inicialização.

Retornos

Boolean

true se o parâmetro input for convertido com êxito; caso contrário, false.

Exceções

ArgumentException

styles inclui um valor de DateTimeStyles indefinido.

-ou-

não há suporte para NoCurrentDateDefault.

-ou-

styles inclui valores de DateTimeStyles mutuamente exclusivos.

Exemplos

O exemplo a seguir define vários formatos de entrada para a representação de cadeia de caracteres de um valor de data e hora e deslocamento e, em seguida, passa a cadeia de caracteres inserida pelo usuário para o método TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset).

TextReader conIn = Console.In;
TextWriter conOut = Console.Out;
int tries = 0;
string input = String.Empty;

string[] formats = new string[] {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz",
                                 "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz",
                                 "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz",
                                 "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz",
                                 "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz",
                                 "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz",
                                 "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz",
                                 "M/d/yy H:m zzz", "MM/d/yy H:m zzz",
                                 "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz",
                                 "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz",
                                 "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz",
                                 "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz",
                                 "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz",
                                 "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz",
                                 "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz",
                                 "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"};
IFormatProvider provider = CultureInfo.InvariantCulture.DateTimeFormat;
DateTimeOffset result;

do {
   conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),");
   conOut.Write("Then press Enter: ");
   input = conIn.ReadLine();
   conOut.WriteLine();
   if (DateTimeOffset.TryParseExact(input, formats, provider,
                                   DateTimeStyles.AllowWhiteSpaces,
                                   out result))
   {
      break;
   }
   else
   {
      Console.WriteLine("Unable to parse {0}.", input);
      tries++;
   }
} while (tries < 3);
if (tries >= 3)
   Console.WriteLine("Exiting application without parsing {0}", input);
else
   Console.WriteLine("{0} was converted to {1}", input, result.ToString());
// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

let mutable result = None    
let mutable tries = 0
let mutable input = ""

let formats = 
    [| "M/dd/yyyy HH:m zzz"; "MM/dd/yyyy HH:m zzz"
       "M/d/yyyy HH:m zzz"; "MM/d/yyyy HH:m zzz"
       "M/dd/yy HH:m zzz"; "MM/dd/yy HH:m zzz"
       "M/d/yy HH:m zzz"; "MM/d/yy HH:m zzz"
       "M/dd/yyyy H:m zzz"; "MM/dd/yyyy H:m zzz"
       "M/d/yyyy H:m zzz"; "MM/d/yyyy H:m zzz"
       "M/dd/yy H:m zzz"; "MM/dd/yy H:m zzz"
       "M/d/yy H:m zzz"; "MM/d/yy H:m zzz"
       "M/dd/yyyy HH:mm zzz"; "MM/dd/yyyy HH:mm zzz"
       "M/d/yyyy HH:mm zzz"; "MM/d/yyyy HH:mm zzz"
       "M/dd/yy HH:mm zzz"; "MM/dd/yy HH:mm zzz"
       "M/d/yy HH:mm zzz"; "MM/d/yy HH:mm zzz"
       "M/dd/yyyy H:mm zzz"; "MM/dd/yyyy H:mm zzz"
       "M/d/yyyy H:mm zzz"; "MM/d/yyyy H:mm zzz"
       "M/dd/yy H:mm zzz"; "MM/dd/yy H:mm zzz"
       "M/d/yy H:mm zzz"; "MM/d/yy H:mm zzz" |]
let provider = CultureInfo.InvariantCulture.DateTimeFormat

while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    input <- stdin.ReadLine()
    printfn ""
    match DateTimeOffset.TryParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) with
    | true, dto ->
        result <- Some dto
    | _ ->
        printfn $"Unable to parse {input}."
    tries <- tries + 1

match result with
| Some result ->
    printfn $"{input} was converted to {result}"
| None ->
    printfn $"Exiting application without parsing {input}"

// Some successful sample interactions with the user might appear as follows:
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/08/2007 6:54 -6:00
//
//    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/8/2007 06:54 -06:00
//
//    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
//
//    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
//    Then press Enter: 12/5/07 6:54 -6:00
//
//    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

 Dim conIn As TextReader = Console.In
 Dim conOut As TextWriter = Console.Out
 Dim tries As Integer = 0
 Dim input As String = String.Empty
 Dim formats() As String = {"M/dd/yyyy HH:m zzz", "MM/dd/yyyy HH:m zzz", _
                            "M/d/yyyy HH:m zzz", "MM/d/yyyy HH:m zzz", _
                            "M/dd/yy HH:m zzz", "MM/dd/yy HH:m zzz", _
                            "M/d/yy HH:m zzz", "MM/d/yy HH:m zzz", _                                 
                            "M/dd/yyyy H:m zzz", "MM/dd/yyyy H:m zzz", _
                            "M/d/yyyy H:m zzz", "MM/d/yyyy H:m zzz", _
                            "M/dd/yy H:m zzz", "MM/dd/yy H:m zzz", _
                            "M/d/yy H:m zzz", "MM/d/yy H:m zzz", _                               
                            "M/dd/yyyy HH:mm zzz", "MM/dd/yyyy HH:mm zzz", _
                            "M/d/yyyy HH:mm zzz", "MM/d/yyyy HH:mm zzz", _
                            "M/dd/yy HH:mm zzz", "MM/dd/yy HH:mm zzz", _
                            "M/d/yy HH:mm zzz", "MM/d/yy HH:mm zzz", _                                 
                            "M/dd/yyyy H:mm zzz", "MM/dd/yyyy H:mm zzz", _
                            "M/d/yyyy H:mm zzz", "MM/d/yyyy H:mm zzz", _
                            "M/dd/yy H:mm zzz", "MM/dd/yy H:mm zzz", _
                            "M/d/yy H:mm zzz", "MM/d/yy H:mm zzz"}   
 Dim provider As IFormatProvider = CultureInfo.InvariantCulture.DateTimeFormat
 Dim result As DateTimeOffset

 Do 
    conOut.WriteLine("Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),")
    conOut.Write("Then press Enter: ")
    input = conIn.ReadLine()
    conOut.WriteLine() 
    If DateTimeOffset.TryParseExact(input, formats, provider, _
                                    DateTimeStyles.AllowWhiteSpaces, _
                                    result) Then
       Exit Do
    Else
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End If
 Loop While tries < 3
 If tries >= 3 Then
    Console.WriteLine("Exiting application without parsing {0}", input)
 Else
    Console.WriteLine("{0} was converted to {1}", input, result.ToString())                                                     
 End If 
 ' Some successful sample interactions with the user might appear as follows:
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/08/2007 6:54 -6:00
 '    
 '    12/08/2007 6:54 -6:00 was converted to 12/8/2007 6:54:00 AM -06:00         
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/8/2007 06:54 -06:00
 '    
 '    12/8/2007 06:54 -06:00 was converted to 12/8/2007 6:54:00 AM -06:00
 '    
 '    Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),
 '    Then press Enter: 12/5/07 6:54 -6:00
 '    
 '    12/5/07 6:54 -6:00 was converted to 12/5/2007 6:54:00 AM -06:00

Comentários

O método TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) analisa a representação de cadeia de caracteres de uma data que corresponde a qualquer um dos padrões atribuídos à matriz formats. Se a cadeia de caracteres input não corresponder a nenhum desses padrões com quaisquer variações definidas pelo parâmetro styles, a operação de análise falhará e o método retornará false. Além de comparar input com várias cadeias de caracteres que contêm especificadores de formato, essa sobrecarga se comporta de forma idêntica ao método DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles).

O parâmetro formats é uma matriz de cadeia de caracteres cujos elementos contêm um único especificador de formato padrão ou um ou mais especificadores de formato personalizado que definem o padrão possível de input. Para obter detalhes sobre códigos de formatação válidos, consulte cadeias de caracteres de formato de data e hora padrão e cadeias de caracteres de formato de data e hora personalizadas. Se o elemento correspondente em formats incluir os especificadores de z, zzou zzz formato personalizado para indicar que um deslocamento deve estar presente em input, esse deslocamento deve incluir um sinal negativo ou um sinal positivo. Se o sinal estiver ausente, a operação de análise falhará e o método retornará false.

Importante

Usar o parâmetro formats dessa sobrecarga para especificar vários formatos pode ajudar a reduzir a frustração que muitos usuários experimentam ao inserir datas e horas. Em particular, a capacidade de definir vários padrões de entrada permite que um aplicativo lide com representações de data e hora que podem incluir ou não zeros à esquerda em meses, dias, horas, minutos e segundos. O exemplo fornece uma ilustração disso.

Se o elemento correspondente no formats exigir que input contenham uma data, mas não uma hora, o objeto DateTimeOffset resultante recebe uma hora de meia-noite (0:00:00). Se o elemento correspondente no formats exigir que a entrada contenha uma hora, mas não uma data, o objeto DateTimeOffset resultante recebe a data atual no sistema local. Se o elemento correspondente em formats não exigir que input contenham um deslocamento, o deslocamento do objeto DateTimeOffset resultante depende do valor do parâmetro styles. Se styles incluir AssumeLocal, o deslocamento do fuso horário local será atribuído ao objeto DateTimeOffset. Se styles incluir AssumeUniversal, o deslocamento UTC (Tempo Universal Coordenado) ou +00:00, será atribuído ao objeto DateTimeOffset. Se nenhum dos valores for especificado, o deslocamento do fuso horário local será usado.

Os símbolos e cadeias de caracteres de data e hora específicos usados em input são definidos pelo parâmetro formatProvider. O mesmo vale para o padrão preciso de input se o elemento correspondente de formats for uma cadeia de caracteres do especificador de formato padrão. O parâmetro formatProvider pode ser um dos seguintes:

Se formatprovider for null, o objeto CultureInfo que corresponde à cultura atual será usado.

O parâmetro styles define se o espaço em branco é permitido na cadeia de caracteres de entrada, indica como cadeias de caracteres sem um componente de deslocamento explícito são analisadas e dá suporte à conversão UTC como parte da operação de análise. Todos os membros da enumeração DateTimeStyles têm suporte, exceto NoCurrentDateDefault. A tabela a seguir lista o efeito de cada membro com suporte.

membro DateTimeStyles Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o em UTC. É equivalente a analisar uma cadeia de caracteres e chamar o método DateTimeOffset.ToUniversalTime do objeto DateTimeOffset retornado.
AssumeLocal Se o elemento correspondente em formats não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento do fuso horário local. Esse é o valor padrão.
AssumeUniversal Se o elemento correspondente no formats não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite que input incluam espaço em branco interno não especificado pelos elementos em formats. O espaço em branco extra pode aparecer entre componentes de data e hora e dentro de componentes individuais (exceto para o deslocamento) e é ignorado ao analisar a cadeia de caracteres.
AllowLeadingWhite Permite que input incluam espaços à esquerda não especificados pelos elementos em formats. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowTrailingWhite Permite que input incluam espaços à direita não especificados pelos elementos em formats. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowWhiteSpaces Permite que input incluam espaços à esquerda, à direita e internos não especificados pelos elementos em formats. Todos os caracteres de espaço em branco extras não especificados no elemento correspondente em formats são ignorados ao analisar a cadeia de caracteres.
None Indica que espaço em branco adicional não é permitido em input. O espaço em branco deve aparecer exatamente como especificado em um elemento específico em formats para que uma correspondência bem-sucedida ocorra. Esse é o comportamento padrão.
RoundtripKind Não tem efeito porque a estrutura de DateTimeOffset não inclui uma propriedade Kind.

Notas aos Chamadores

No .NET Framework 4, o TryParseExact retornará false se a cadeia de caracteres a ser analisada contiver um componente de hora e um designador AM/PM que não estão de acordo. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Aplica-se a

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

Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs

Converte a representação de uma data e hora em um intervalo de caracteres em seu DateTimeOffset equivalente usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato da representação de data e hora deve corresponder exatamente ao formato especificado.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parâmetros

input
ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam uma data e hora a serem convertidos.

format
ReadOnlySpan<Char>

Um especificador de formato que define o formato necessário de input.

formatProvider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre input.

styles
DateTimeStyles

Uma combinação bit a bit de valores de enumeração que indica o formato permitido de input. Um valor típico a ser especificado é None.

result
DateTimeOffset

Quando o método é retornado, contém o DateTimeOffset equivalente à data e hora de input, se a conversão foi bem-sucedida ou DateTimeOffset.MinValue se a conversão falhou. A conversão falhará se o

Retornos

Boolean

true se o parâmetro input for convertido com êxito; caso contrário, false.

Exceções

ArgumentException

styles inclui um valor de DateTimeStyles indefinido. Não há suporte para NoCurrentDateDefault. -ou- styles inclui valores de DateTimeStyles mutuamente exclusivos.

Comentários

Essa sobrecarga é como o método DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles), exceto que esse método não gera uma exceção se a conversão falhar. Ele analisa a representação de uma data e hora que deve corresponder exatamente ao padrão especificado pelo parâmetro format. Se input não corresponder a esse padrão, com algumas possíveis variações no espaço em branco definidas pelo parâmetro styles, a operação de análise falhará e o método retornará false.

O parâmetro format é um intervalo de caracteres que contém um único especificador de formato padrão ou um ou mais especificadores de formato personalizado que definem o padrão necessário de input. Para obter detalhes sobre códigos de formatação válidos, consulte cadeias de caracteres de formato de data e hora padrão e cadeias de caracteres de formato de data e hora personalizadas. Se format incluir os especificadores de formato personalizado z, zzou zzz para indicar que um deslocamento deve estar presente em input, esse deslocamento deve incluir um sinal negativo ou um sinal positivo. Se o sinal estiver ausente, a operação de análise falhará e o método retornará false.

Se format exigir que input contenham uma data, mas não uma hora, o objeto DateTimeOffset resultante recebe uma hora de meia-noite (0:00:00). Se format exigir que input contenham uma hora, mas não uma data, o objeto DateTimeOffset resultante recebe a data atual no sistema local. Se format não exigir que input contenham um deslocamento, o deslocamento do objeto DateTimeOffset resultante dependerá do valor do parâmetro styles. Se styles incluir AssumeLocal, o deslocamento do fuso horário local será atribuído ao objeto DateTimeOffset. Se styles incluir AssumeUniversal, o deslocamento UTC (Tempo Universal Coordenado) ou +00:00, será atribuído ao objeto DateTimeOffset. Se nenhum dos valores for especificado, o deslocamento do fuso horário local será usado.

Os símbolos e cadeias de caracteres de data e hora específicos usados em input são definidos pelo parâmetro formatProvider. O mesmo vale para o padrão preciso de input se format for uma cadeia de caracteres do especificador de formato padrão. O parâmetro formatProvider pode ser um dos seguintes:

Se formatprovider for null, o objeto CultureInfo que corresponde à cultura atual será usado.

O parâmetro styles define se o espaço em branco é permitido na cadeia de caracteres de entrada, indica como cadeias de caracteres sem um componente de deslocamento explícito são analisadas e dá suporte à conversão UTC como parte da operação de análise. Todos os membros da enumeração DateTimeStyles têm suporte, exceto NoCurrentDateDefault. A tabela a seguir lista o efeito de cada membro com suporte.

membro DateTimeStyles Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o em UTC. É equivalente à análise de uma representação de data e hora e, em seguida, chamar o método DateTimeOffset.ToUniversalTime do objeto DateTimeOffset retornado.
AssumeLocal Se format não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento do fuso horário local. Esse é o comportamento padrão.
AssumeUniversal Se format não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite que input incluam espaço em branco interno não especificado por formato. O espaço em branco extra pode aparecer entre componentes de data e hora e dentro de componentes individuais, além do deslocamento, e é ignorado ao analisar a cadeia de caracteres.
AllowLeadingWhite Permite que input incluam espaços à esquerda não especificados por format. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowTrailingWhite Permite que input incluam espaços à direita não especificados por format. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowWhiteSpaces Permite que input incluam espaços à esquerda, à direita e internos não especificados por format. Todos os caracteres de espaço em branco extras não especificados em format são ignorados ao analisar a cadeia de caracteres.
None Indica que espaço em branco adicional não é permitido em input. O espaço em branco deve aparecer exatamente como especificado em format. Esse é o comportamento padrão.
RoundtripKind Não tem efeito, pois a estrutura DateTimeOffset não inclui uma propriedade Kind.

Aplica-se a

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

Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs

Converte a representação de uma data e hora em um intervalo de caracteres em seu DateTimeOffset equivalente usando os formatos especificados, as informações de formato específicas da cultura e o estilo. O formato da representação de data e hora deve corresponder exatamente a um dos formatos especificados.

public:
 static bool TryParseExact(ReadOnlySpan<char> input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (ReadOnlySpan<char> input, string?[]? formats, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parâmetros

input
ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam uma data e hora a serem convertidos.

formats
String[]

Uma matriz de cadeias de caracteres de formato padrão ou personalizado que definem os formatos aceitáveis de input.

formatProvider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre input.

styles
DateTimeStyles

Uma combinação bit a bit de valores de enumeração que indica o formato permitido de input. Um valor típico a ser especificado é None.

result
DateTimeOffset

Quando o método é retornado, contém o DateTimeOffset equivalente à data e hora de input, se a conversão foi bem-sucedida ou DateTimeOffset.MinValue se a conversão falhou. A conversão falhará se o

Retornos

Boolean

true se o parâmetro input for convertido com êxito; caso contrário, false.

Exceções

ArgumentException

styles inclui um valor de DateTimeStyles indefinido. Não há suporte para NoCurrentDateDefault. -ou- styles inclui valores de DateTimeStyles mutuamente exclusivos.

Comentários

Esse método analisa a representação de cadeia de caracteres de uma data que corresponde a qualquer um dos padrões atribuídos à matriz formats. Se input não corresponder a nenhum desses padrões com quaisquer variações definidas pelo parâmetro styles, a operação de análise falhará e o método retornará false. Além de comparar input com várias cadeias de caracteres que contêm especificadores de formato, essa sobrecarga se comporta de forma idêntica ao método DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles).

O parâmetro formats é uma matriz de cadeia de caracteres cujos elementos contêm um único especificador de formato padrão ou um ou mais especificadores de formato personalizado que definem o padrão possível de input. Para obter detalhes sobre códigos de formatação válidos, consulte cadeias de caracteres de formato de data e hora padrão e cadeias de caracteres de formato de data e hora personalizadas. Se o elemento correspondente em formats incluir os especificadores de z, zzou zzz formato personalizado para indicar que um deslocamento deve estar presente em input, esse deslocamento deve incluir um sinal negativo ou um sinal positivo. Se o sinal estiver ausente, a operação de análise falhará e o método retornará false.

Importante

Usar o parâmetro formats dessa sobrecarga para especificar vários formatos pode ajudar a reduzir a frustração que muitos usuários experimentam ao inserir datas e horas. Em particular, a capacidade de definir vários padrões de entrada permite que um aplicativo lide com representações de data e hora que podem incluir ou não zeros à esquerda em meses, dias, horas, minutos e segundos. O exemplo fornece uma ilustração disso.

Se o elemento correspondente no formats exigir que input contenham uma data, mas não uma hora, o objeto DateTimeOffset resultante recebe uma hora de meia-noite (0:00:00). Se o elemento correspondente no formats exigir que a entrada contenha uma hora, mas não uma data, o objeto DateTimeOffset resultante recebe a data atual no sistema local. Se o elemento correspondente em formats não exigir que input contenham um deslocamento, o deslocamento do objeto DateTimeOffset resultante depende do valor do parâmetro styles. Se styles incluir DateTimeStyles.AssumeLocal, o deslocamento do fuso horário local será atribuído ao objeto DateTimeOffset. Se styles incluir DateTimeStyles.AssumeUniversal, o deslocamento UTC (Tempo Universal Coordenado) ou +00:00, será atribuído ao objeto DateTimeOffset. Se nenhum dos valores for especificado, o deslocamento do fuso horário local será usado.

Os símbolos de data e hora específicos usados em input são definidos pelo parâmetro formatProvider. O mesmo vale para o padrão preciso de input se o elemento correspondente de formats for uma cadeia de caracteres do especificador de formato padrão. O parâmetro formatProvider pode ser um dos seguintes:

Se formatprovider for null, o objeto CultureInfo que corresponde à cultura atual será usado.

O parâmetro styles define se o espaço em branco é permitido na cadeia de caracteres de entrada, indica como cadeias de caracteres sem um componente de deslocamento explícito são analisadas e dá suporte à conversão UTC como parte da operação de análise. Todos os membros da enumeração DateTimeStyles têm suporte, exceto NoCurrentDateDefault. A tabela a seguir lista o efeito de cada membro com suporte.

membro DateTimeStyles Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o em UTC. É equivalente a analisar uma cadeia de caracteres e chamar o método DateTimeOffset.ToUniversalTime do objeto DateTimeOffset retornado.
AssumeLocal Se o elemento correspondente em formats não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento do fuso horário local. Esse é o valor padrão.
AssumeUniversal Se o elemento correspondente no formats não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite que input incluam espaço em branco interno não especificado pelos elementos em formats. O espaço em branco extra pode aparecer entre componentes de data e hora e dentro de componentes individuais (exceto para o deslocamento) e é ignorado ao analisar a cadeia de caracteres.
AllowLeadingWhite Permite que input incluam espaços à esquerda não especificados pelos elementos em formats. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowTrailingWhite Permite que input incluam espaços à direita não especificados pelos elementos em formats. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowWhiteSpaces Permite que input incluam espaços à esquerda, à direita e internos não especificados pelos elementos em formats. Todos os caracteres de espaço em branco extras não especificados no elemento correspondente em formats são ignorados ao analisar a cadeia de caracteres.
None Indica que espaço em branco adicional não é permitido em input. O espaço em branco deve aparecer exatamente como especificado em um elemento específico em formats para que uma correspondência bem-sucedida ocorra. Esse é o comportamento padrão.
RoundtripKind Não tem efeito porque a estrutura de DateTimeOffset não inclui uma propriedade Kind.

Aplica-se a

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset)

Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs
Origem:
DateTimeOffset.cs

Converte a representação de cadeia de caracteres especificada de uma data e hora em seu DateTimeOffset equivalente usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato da representação de cadeia de caracteres deve corresponder exatamente ao formato especificado.

public:
 static bool TryParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles, [Runtime::InteropServices::Out] DateTimeOffset % result);
public static bool TryParseExact (string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
public static bool TryParseExact (string? input, string? format, IFormatProvider? formatProvider, System.Globalization.DateTimeStyles styles, out DateTimeOffset result);
static member TryParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles * DateTimeOffset -> bool
Public Shared Function TryParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles, ByRef result As DateTimeOffset) As Boolean

Parâmetros

input
String

Uma cadeia de caracteres que contém uma data e hora a serem convertidas.

format
String

Um especificador de formato que define o formato necessário de input.

formatProvider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre input.

styles
DateTimeStyles

Uma combinação bit a bit de valores de enumeração que indica o formato permitido de entrada. Um valor típico a ser especificado é None.

result
DateTimeOffset

Quando o método é retornado, contém o DateTimeOffset equivalente à data e hora de input, se a conversão foi bem-sucedida ou DateTimeOffset.MinValue, se a conversão falhou. A conversão falhará se o parâmetro input for nullou não contiver uma representação de cadeia de caracteres válida de uma data e hora no formato esperado definido por format e provider. Esse parâmetro é passado sem inicialização.

Retornos

Boolean

true se o parâmetro input for convertido com êxito; caso contrário, false.

Exceções

ArgumentException

styles inclui um valor de DateTimeStyles indefinido.

-ou-

não há suporte para NoCurrentDateDefault.

-ou-

styles inclui valores de DateTimeStyles mutuamente exclusivos.

Exemplos

O exemplo a seguir usa o método TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) com especificadores de formato padrão e personalizado, a cultura invariável e vários valores DateTimeStyles para analisar várias cadeias de caracteres de data e hora.

string dateString, format;
DateTimeOffset result;
IFormatProvider provider = CultureInfo.InvariantCulture;

// Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008";
format = "d";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AssumeUniversal,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowTrailingWhite,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00";
format = "MM/dd/yyyy H:mm zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                 DateTimeStyles.AllowWhiteSpaces,
                                 out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);

// Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00";
format = "MM/dd/yyyy H:mm:ss zzz";
if (DateTimeOffset.TryParseExact(dateString, format, provider,
                                DateTimeStyles.AllowWhiteSpaces |
                                DateTimeStyles.AdjustToUniversal,
                                out result))
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
else
   Console.WriteLine("'{0}' is not in the correct format.", dateString);
// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture and assume time is UTC.
let dateString = "06/15/2008"
let format = "d"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should return False because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time value, and allow all white space.
let dateString = " 06/15/   2008  15:15    -05:00"
let format = "MM/dd/yyyy H:mm zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date and time and convert to UTC.
let dateString = "  06/15/2008 15:15:30 -05:00"
let format = "MM/dd/yyyy H:mm:ss zzz"
match DateTimeOffset.TryParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces ||| DateTimeStyles.AdjustToUniversal) with
| true, result ->
    printfn $"'{dateString}' converts to {result}."
| _ ->
    printfn $"'{dateString}' is not in the correct format."

// The example displays the following output:
//    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
//    ' 06/15/2008' is not in the correct format.
//    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
//    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

Dim dateString, format As String  
Dim result As DateTimeOffset
Dim provider As CultureInfo = CultureInfo.InvariantCulture

' Parse date-only value with invariant culture and assume time is UTC.
dateString = "06/15/2008"
format = "d"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                   DateTimeStyles.AssumeUniversal, _
                                   result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date-only value with leading white space.
' Should return False because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowTrailingWhite, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time value, and allow all white space.
dateString = " 06/15/   2008  15:15    -05:00"
format = "MM/dd/yyyy H:mm zzz"
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 

' Parse date and time and convert to UTC.
dateString = "  06/15/2008 15:15:30 -05:00"   
format = "MM/dd/yyyy H:mm:ss zzz"       
If DateTimeOffset.TryParseExact(dateString, format, provider, _
                                DateTimeStyles.AllowWhiteSpaces Or _
                                DateTimeStyles.AdjustToUniversal, _
                                result) Then
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Else
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End If 
' The example displays the following output:
'    '06/15/2008' converts to 6/15/2008 12:00:00 AM +00:00.
'    ' 06/15/2008' is not in the correct format.
'    ' 06/15/   2008  15:15    -05:00' converts to 6/15/2008 3:15:00 PM -05:00.
'    '  06/15/2008 15:15:30 -05:00' converts to 6/15/2008 8:15:30 PM +00:00.

O exemplo a seguir usa uma variedade de valores DateTimeStyles para analisar uma matriz de cadeias de caracteres que devem estar em conformidade com ISO 8601. Como mostra a saída do exemplo, as cadeias de caracteres que estão no formato adequado falharão ao analisar se:

As cadeias de caracteres que não especificam um deslocamento UTC devem ter o deslocamento do fuso horário local (neste caso, -07:00, que reflete o deslocamento do fuso horário de verão do Pacífico), a menos que o sinalizador de DateTimeStyles.AssumeUniversal seja fornecido na chamada do método. Nesse caso, supõe-se que eles sejam Tempo Coordenado Universal.

open System
open System.Globalization

let parseWithISO8601 dateStrings styles =
    printfn $"Parsing with {styles}:"
    for dateString in dateStrings do
        match DateTimeOffset.TryParseExact(dateString, "O", null, styles) with
        | true, date ->
            printfn $"""   {dateString,-35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
        | _ ->
            printfn $"   Unable to convert '{dateString}'"

let dateStrings = 
    [ "2018-08-18T12:45:16.0000000Z"
      "2018/08/18T12:45:16.0000000Z"
      "2018-18-08T12:45:16.0000000Z"
      "2018-08-18T12:45:16.0000000"
      " 2018-08-18T12:45:16.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

parseWithISO8601 dateStrings DateTimeStyles.None
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AllowWhiteSpaces
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AdjustToUniversal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeLocal
printfn "\n-----\n"
parseWithISO8601 dateStrings DateTimeStyles.AssumeUniversal

// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "2018-08-18T12:45:16.0000000Z",
                               "2018/08/18T12:45:16.0000000Z",
                               "2018-18-08T12:45:16.0000000Z",
                               "2018-08-18T12:45:16.0000000",                               
                               " 2018-08-18T12:45:16.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal);
      Console.WriteLine("\n-----\n");
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal);   }

   private static void ParseWithISO8601(string[] dateStrings, DateTimeStyles styles)
   {   
      Console.WriteLine($"Parsing with {styles}:");
      DateTimeOffset date;
      foreach (var dateString in dateStrings)
      {
         if (DateTimeOffset.TryParseExact(dateString, "O", null, styles, out date))
         {
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         else
         {
            Console.WriteLine($"   Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      Parsing with None:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AllowWhiteSpaces:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AdjustToUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
//
//      -----
//
//      Parsing with AssumeLocal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
//
//      -----
//
//      Parsing with AssumeUniversal:
//         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//         Unable to convert '2018/08/18T12:45:16.0000000Z'
//         Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
//         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
//         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim dateStrings() = { "2018-08-18T12:45:16.0000000Z",
                            "2018/08/18T12:45:16.0000000Z",
                            "2018-18-08T12:45:16.0000000Z",
                            "2018-08-18T12:45:16.0000000",                               
                            " 2018-08-18T12:45:16.0000000Z ",
                            "2018-08-18T12:45:16.0000000+02:00",
                            "2018-08-18T12:45:16.0000000-07:00" } 
      
      ParseWithISO8601(dateStrings, DateTimeStyles.None)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AllowWhiteSpaces)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AdjustToUniversal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeLocal)
      Console.WriteLine($"{vbCrLf}-----{vbCrLf}")
      ParseWithISO8601(dateStrings, DateTimeStyles.AssumeUniversal)   
   End Sub

   Private Sub ParseWithISO8601(dateStrings() As String, styles As DateTimeStyles)
      Console.WriteLine($"Parsing with {styles}:")
      Dim dat As DateTimeOffset
      For Each dateStr In dateStrings
         If DateTimeOffset.TryParseExact(dateStr, "O", Nothing, styles, dat) Then
            Console.WriteLine($"   {dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Else
            Console.WriteLine($"   Unable to convert '{dateStr}'")
         End If   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'          2018-08-18T12:45:16.0000000Z       --> 2018-08-18 12:45:16 +00:00
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 10:45:16 +00:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 19:45:16 +00:00
'
'      -----
'
'      Parsing with AssumeLocal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00
'
'      -----
'
'      Parsing with AssumeUniversal:
'         2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'         Unable to convert '2018/08/18T12:45:16.0000000Z'
'         Unable to convert '2018-18-08T12:45:16.0000000Z'
'         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
'         Unable to convert ' 2018-08-18T12:45:16.0000000Z '
'         2018-08-18T12:45:16.0000000+02:00   --> 2018-08-18 12:45:16 +02:00
'         2018-08-18T12:45:16.0000000-07:00   --> 2018-08-18 12:45:16 -07:00

Comentários

Essa sobrecarga do método TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) é como o método DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles), exceto que esse método não gera uma exceção se a conversão falhar. Ele analisa a representação de cadeia de caracteres de uma data e hora que deve corresponder exatamente ao padrão especificado pelo parâmetro format. Se a cadeia de caracteres input não corresponder a esse padrão, com algumas possíveis variações no espaço em branco definidas pelo parâmetro styles, a operação de análise falhará e o método retornará false.

O parâmetro format é uma cadeia de caracteres que contém um único especificador de formato padrão ou um ou mais especificadores de formato personalizado que definem o padrão necessário de input. Para obter detalhes sobre códigos de formatação válidos, consulte cadeias de caracteres de formato de data e hora padrão e cadeias de caracteres de formato de data e hora personalizadas. Se format incluir os especificadores de formato personalizado z, zzou zzz para indicar que um deslocamento deve estar presente em input, esse deslocamento deve incluir um sinal negativo ou um sinal positivo. Se o sinal estiver ausente, a operação de análise falhará e o método retornará false.

Se format exigir que input contenham uma data, mas não uma hora, o objeto DateTimeOffset resultante recebe uma hora de meia-noite (0:00:00). Se format exigir que input contenham uma hora, mas não uma data, o objeto DateTimeOffset resultante recebe a data atual no sistema local. Se format não exigir que input contenham um deslocamento, o deslocamento do objeto DateTimeOffset resultante dependerá do valor do parâmetro styles. Se styles incluir AssumeLocal, o deslocamento do fuso horário local será atribuído ao objeto DateTimeOffset. Se styles incluir AssumeUniversal, o deslocamento UTC (Tempo Universal Coordenado) ou +00:00, será atribuído ao objeto DateTimeOffset. Se nenhum dos valores for especificado, o deslocamento do fuso horário local será usado.

Os símbolos e cadeias de caracteres de data e hora específicos usados em input são definidos pelo parâmetro formatProvider. O mesmo vale para o padrão preciso de input se format for uma cadeia de caracteres do especificador de formato padrão. O parâmetro formatProvider pode ser um dos seguintes:

Se formatprovider for null, o objeto CultureInfo que corresponde à cultura atual será usado.

O parâmetro styles define se o espaço em branco é permitido na cadeia de caracteres de entrada, indica como cadeias de caracteres sem um componente de deslocamento explícito são analisadas e dá suporte à conversão UTC como parte da operação de análise. Todos os membros da enumeração DateTimeStyles têm suporte, exceto NoCurrentDateDefault. A tabela a seguir lista o efeito de cada membro com suporte.

membro DateTimeStyles Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o em UTC. É equivalente a analisar uma cadeia de caracteres e chamar o método DateTimeOffset.ToUniversalTime do objeto DateTimeOffset retornado.
AssumeLocal Se format não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento do fuso horário local. Esse é o comportamento padrão.
AssumeUniversal Se format não exigir que input contenham um valor de deslocamento, o objeto DateTimeOffset retornado recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite que input incluam espaço em branco interno não especificado por formato. O espaço em branco extra pode aparecer entre componentes de data e hora e dentro de componentes individuais, além do deslocamento, e é ignorado ao analisar a cadeia de caracteres.
AllowLeadingWhite Permite que input incluam espaços à esquerda não especificados por format. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowTrailingWhite Permite que input incluam espaços à direita não especificados por format. Elas são ignoradas ao analisar a cadeia de caracteres.
AllowWhiteSpaces Permite que input incluam espaços à esquerda, à direita e internos não especificados por format. Todos os caracteres de espaço em branco extras não especificados em format são ignorados ao analisar a cadeia de caracteres.
None Indica que espaço em branco adicional não é permitido em input. O espaço em branco deve aparecer exatamente como especificado em format. Esse é o comportamento padrão.
RoundtripKind Não tem efeito, pois a estrutura DateTimeOffset não inclui uma propriedade Kind.

Notas aos Chamadores

No .NET Framework 4, o TryParseExact retornará false se a cadeia de caracteres a ser analisada contiver um componente de hora e um designador AM/PM que não estão de acordo. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Confira também

Aplica-se a