DateTimeOffset.TryParseExact Método

Definição

Espaço de Nomes:
System
Assemblagens:
mscorlib.dll, System.Runtime.dll
Assemblagem:
mscorlib.dll
Assemblagem:
System.Runtime.dll
Assemblagem:
netstandard.dll

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

Sobrecargas

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

Converte a representação de cadeias especificada de uma data e hora para o seu DateTimeOffset equivalente usando o array especificado de formatos, informação de formato específica de cultura e estilo. O formato da representação da cadeia 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 num intervalo de caracteres para o seu DateTimeOffset equivalente, usando o formato especificado, informação de formato específica da cultura e estilo. O formato da data e hora da representação deve corresponder exatamente ao formato especificado.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTimeOffset)

Converte a representação de uma data e hora num intervalo de caracteres para o seu DateTimeOffset equivalente usando os formatos especificados, informação de formato específica da cultura e 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 em cadeia especificada de uma data e hora para o seu DateTimeOffset equivalente usando o formato especificado, informação de formato específica da cultura e estilo. O formato da representação da cadeia deve corresponder exatamente ao formato especificado.

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

Converte a representação de cadeias especificada de uma data e hora para o seu DateTimeOffset equivalente usando o array especificado de formatos, informação de formato específica de cultura e estilo. O formato da representação da cadeia 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);
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 que contém uma data e hora para converter.

formats
String[]

Um array que define os formatos esperados de input.

formatProvider
IFormatProvider

Um objeto que fornece informação de formatação específica de 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 especificar é None.

result
DateTimeOffset

Quando o método retorna, 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 falha se o input não contiver uma representação válida de uma cadeia de caracteres de uma data e hora, ou não contiver a data e hora no formato esperado definido por formats, ou se formats for null. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

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

Exceções

ArgumentException

styles inclui um valor indefinido DateTimeStyles .

-ou-

NoCurrentDateDefault não é suportado.

-ou-

styles inclui valores mutuamente exclusivos DateTimeStyles .

Exemplos

O exemplo seguinte define múltiplos formatos de entrada para a representação de uma data e hora e valor de deslocamento, e depois passa a cadeia introduzida pelo utilizador ao TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) método.

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

Observações

O TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTimeOffset) método analisa a representação da string de uma data que corresponde a qualquer um dos padrões atribuídos ao formats array. Se a input cadeia não corresponder a nenhum destes padrões com quaisquer variações definidas pelo styles parâmetro, a operação de análise falha e o método devolve false. Para além de comparar input com múltiplas cadeias que contêm especificadores de formato, esta sobrecarga comporta-se de forma idêntica ao DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método.

O formats parâmetro é um array de strings cujos elementos contêm ou um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o possível padrão de input. Para detalhes sobre códigos de formatação válidos, consulte Cadeias de Formato Padrão de Data e Hora e Cadeias de Formatos Personalizados de Data e Hora. Se o elemento emparelhado em formats incluir os z, zz, ou zzz especificadores de formato personalizados para indicar que deve haver um deslocamento em input, esse deslocamento deve incluir ou um sinal negativo ou um sinal positivo. Se o sinal estiver em falta, a operação de análise falha e o método devolve false.

Importante

Usar o formats parâmetro desta sobrecarga para especificar múltiplos formatos pode ajudar a reduzir a frustração que muitos utilizadores sentem ao introduzirem datas e horas. Em particular, a capacidade de definir múltiplos padrões de entrada permite a uma aplicação tratar representações de data e hora que podem incluir ou não zeros iniciais em meses, dias, horas, minutos e segundos. O exemplo fornece uma ilustração disto.

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

Os símbolos e strings de data e hora usados em input são definidos pelo formatProvider parâmetro. O mesmo se aplica ao padrão preciso de input se o elemento correspondente de formats for uma cadeia especificadora de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

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

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

DateTimeStyles Membro Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o para UTC. É equivalente a analisar uma cadeia e depois chamar o DateTimeOffset.ToUniversalTime método do objeto devolvido DateTimeOffset .
AssumeLocal Se o elemento correspondido em formats não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento do fuso horário local. Este é o valor padrão.
AssumeUniversal Se o elemento emparelhado em formats não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite input incluir espaços em branco internos não especificados pelos elementos em formats. Pode aparecer espaço em branco extra entre componentes de data e hora e dentro de componentes individuais (exceto o deslocamento) e é ignorado ao analisar a cadeia.
AllowLeadingWhite Permite input incluir espaços iniciais não especificados pelos elementos em formats. Estas são ignoradas ao analisar a sequência.
AllowTrailingWhite Permite input incluir espaços finais não especificados pelos elementos em formats. Estas são ignoradas ao analisar a sequência.
AllowWhiteSpaces Permite input incluir os espaços de entrada, de origem e interior não especificados pelos elementos em formats. Todos os caracteres de espaço em branco extra não especificados no elemento correspondente em formats são ignorados ao analisar a cadeia.
None Indica que não é permitido espaço em branco adicional em input. O espaço em branco deve aparecer exatamente como especificado num determinado elemento de formats para que ocorra uma correspondência bem-sucedida. Este é o comportamento padrão.
RoundtripKind Não tem efeito porque a DateTimeOffset estrutura não inclui uma Kind propriedade.

Notas para Chamadores

No .NET Framework 4, o TryParseExact devolve false se a cadeia a analisar contiver um componente de horas e um designador AM/PM que não estejam em concordância. 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)

Converte a representação de uma data e hora num intervalo de caracteres para o seu DateTimeOffset equivalente, usando o formato especificado, informação de formato específica da cultura e estilo. O formato da data e hora da representação 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);
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 espaço que contém os caracteres que representam uma data e hora para converter.

format
ReadOnlySpan<Char>

Um especificador de formato que define o formato requerido de input.

formatProvider
IFormatProvider

Um objeto que fornece informação de formatação específica de 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 especificar é None.

result
DateTimeOffset

Quando o método retorna, 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

Devoluções

Boolean

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

Exceções

ArgumentException

styles inclui um valor indefinido DateTimeStyles . -ou- NoCurrentDateDefault não é suportado. -ou- styles inclui valores mutuamente exclusivos DateTimeStyles .

Observações

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

O format parâmetro é um intervalo de caracteres que contém ou um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o padrão requerido de input. Para detalhes sobre códigos de formatação válidos, consulte Cadeias de Formato Padrão de Data e Hora e Cadeias de Formatos Personalizados de Data e Hora. Se format inclui os z, zz, ou zzz especificadores de formato personalizados para indicar que um deslocamento deve estar presente em input, esse deslocamento deve incluir ou um sinal negativo ou um sinal positivo. Se o sinal estiver em falta, a operação de análise falha e o método devolve false.

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

Os símbolos e strings de data e hora usados em input são definidos pelo formatProvider parâmetro. O mesmo se aplica ao padrão preciso de input se format for uma cadeia especificadora de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

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

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

DateTimeStyles Membro Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o para UTC. É equivalente a analisar uma representação de data e hora, e depois chamar o DateTimeOffset.ToUniversalTime método do objeto devolvido DateTimeOffset .
AssumeLocal Se format não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento do fuso horário local. Este é o comportamento padrão.
AssumeUniversal Se format não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite input incluir espaço em branco interno não especificado pelo formato. Pode surgir espaço em branco extra entre componentes de data e hora e dentro de componentes individuais, exceto o deslocamento, sendo ignorado ao analisar a cadeia.
AllowLeadingWhite Permite input incluir espaços à frente não especificados por format. Estas são ignoradas ao analisar a sequência.
AllowTrailingWhite Permite input incluir espaços finais não especificados por format. Estas são ignoradas ao analisar a sequência.
AllowWhiteSpaces Permite input incluir espaços de frente, de final e interiores não especificados por format. Todos os caracteres de espaço em branco extra não especificados em format são ignorados ao analisar a cadeia.
None Indica que não é permitido espaço em branco adicional em input. O espaço em branco deve aparecer exatamente como especificado em format. Este é o comportamento padrão.
RoundtripKind Não tem efeito, porque a DateTimeOffset estrutura não inclui uma Kind propriedade.

Aplica-se a

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

Converte a representação de uma data e hora num intervalo de caracteres para o seu DateTimeOffset equivalente usando os formatos especificados, informação de formato específica da cultura e 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);
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 espaço que contém os caracteres que representam uma data e hora para converter.

formats
String[]

Um array de cadeias de formatos padrão ou personalizadas que definem os formatos aceitáveis de input.

formatProvider
IFormatProvider

Um objeto que fornece informação de formatação específica de 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 especificar é None.

result
DateTimeOffset

Quando o método retorna, 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

Devoluções

Boolean

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

Exceções

ArgumentException

styles inclui um valor indefinido DateTimeStyles . -ou- NoCurrentDateDefault não é suportado. -ou- styles inclui valores mutuamente exclusivos DateTimeStyles .

Observações

Este método analisa a representação da string de uma data que corresponde a qualquer um dos padrões atribuídos ao formats array. Se input não corresponder a nenhum destes padrões com quaisquer variações definidas pelo styles parâmetro, a operação de análise falha e o método retorna false. Para além de comparar input com múltiplas cadeias que contêm especificadores de formato, esta sobrecarga comporta-se de forma idêntica ao DateTimeOffset.ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles) método.

O formats parâmetro é um array de strings cujos elementos contêm ou um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o possível padrão de input. Para detalhes sobre códigos de formatação válidos, consulte Cadeias de Formato Padrão de Data e Hora e Cadeias de Formatos Personalizados de Data e Hora. Se o elemento emparelhado em formats incluir os z, zz, ou zzz especificadores de formato personalizados para indicar que deve haver um deslocamento em input, esse deslocamento deve incluir ou um sinal negativo ou um sinal positivo. Se o sinal estiver em falta, a operação de análise falha e o método devolve false.

Importante

Usar o formats parâmetro desta sobrecarga para especificar múltiplos formatos pode ajudar a reduzir a frustração que muitos utilizadores sentem ao introduzirem datas e horas. Em particular, a capacidade de definir múltiplos padrões de entrada permite a uma aplicação tratar representações de data e hora que podem incluir ou não zeros iniciais em meses, dias, horas, minutos e segundos. O exemplo fornece uma ilustração disto.

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

Os símbolos de data e hora usados em input são definidos pelo formatProvider parâmetro. O mesmo se aplica ao padrão preciso de input se o elemento correspondente de formats for uma cadeia especificadora de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

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

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

DateTimeStyles Membro Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o para UTC. É equivalente a analisar uma cadeia e depois chamar o DateTimeOffset.ToUniversalTime método do objeto devolvido DateTimeOffset .
AssumeLocal Se o elemento correspondido em formats não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento do fuso horário local. Este é o valor padrão.
AssumeUniversal Se o elemento emparelhado em formats não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite input incluir espaços em branco internos não especificados pelos elementos em formats. Pode aparecer espaço em branco extra entre componentes de data e hora e dentro de componentes individuais (exceto o deslocamento) e é ignorado ao analisar a cadeia.
AllowLeadingWhite Permite input incluir espaços iniciais não especificados pelos elementos em formats. Estas são ignoradas ao analisar a sequência.
AllowTrailingWhite Permite input incluir espaços finais não especificados pelos elementos em formats. Estas são ignoradas ao analisar a sequência.
AllowWhiteSpaces Permite input incluir os espaços de entrada, de origem e interior não especificados pelos elementos em formats. Todos os caracteres de espaço em branco extra não especificados no elemento correspondente em formats são ignorados ao analisar a cadeia.
None Indica que não é permitido espaço em branco adicional em input. O espaço em branco deve aparecer exatamente como especificado num determinado elemento de formats para que ocorra uma correspondência bem-sucedida. Este é o comportamento padrão.
RoundtripKind Não tem efeito porque a DateTimeOffset estrutura não inclui uma Kind propriedade.

Aplica-se a

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

Converte a representação em cadeia especificada de uma data e hora para o seu DateTimeOffset equivalente usando o formato especificado, informação de formato específica da cultura e estilo. O formato da representação da cadeia 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);
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 que contém uma data e hora para converter.

format
String

Um especificador de formato que define o formato requerido de input.

formatProvider
IFormatProvider

Um objeto que fornece informação de formatação específica de 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 especificar é None.

result
DateTimeOffset

Quando o método retorna, 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 falha se o input parâmetro for null, ou não contiver uma representação válida de uma string data e hora no formato esperado definido por format e provider. Este parâmetro é passado sem inicializar.

Devoluções

Boolean

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

Exceções

ArgumentException

styles inclui um valor indefinido DateTimeStyles .

-ou-

NoCurrentDateDefault não é suportado.

-ou-

styles inclui valores mutuamente exclusivos DateTimeStyles .

Exemplos

O exemplo seguinte utiliza o TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) método com especificadores de formato padrão e personalizados, a cultura invariante e vários DateTimeStyles valores para analisar várias cadeias 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 seguinte utiliza uma variedade de DateTimeStyles valores para analisar um array de cadeias que se espera que cumpram a ISO 8601. Como o resultado do exemplo mostra, as cadeias que estão no formato correto falham em analisar se:

As cadeias que não especificam um deslocamento UTC são assumidas como tendo 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 a DateTimeStyles.AssumeUniversal bandeira seja fornecida na chamada de método. Nesse caso, assume-se que são 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

Observações

Esta sobrecarga do TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTimeOffset) método é semelhante ao DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) método, exceto que este método não lança uma exceção se a conversão falhar. Analisa a representação da cadeia de uma data e hora que devem corresponder exatamente ao padrão especificado pelo format parâmetro. Se a input cadeia não corresponder a este padrão, com algumas possíveis variações no espaço em branco definidas pelo styles parâmetro, a operação de análise falha e o método devolve false.

O format parâmetro é uma cadeia que contém ou um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o padrão requerido de input. Para detalhes sobre códigos de formatação válidos, consulte Cadeias de Formato Padrão de Data e Hora e Cadeias de Formatos Personalizados de Data e Hora. Se format inclui os z, zz, ou zzz especificadores de formato personalizados para indicar que um deslocamento deve estar presente em input, esse deslocamento deve incluir ou um sinal negativo ou um sinal positivo. Se o sinal estiver em falta, a operação de análise falha e o método devolve false.

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

Os símbolos e strings de data e hora usados em input são definidos pelo formatProvider parâmetro. O mesmo se aplica ao padrão preciso de input se format for uma cadeia especificadora de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

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

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

DateTimeStyles Membro Comportamento
AdjustToUniversal Analisa input e, se necessário, converte-o para UTC. É equivalente a analisar uma cadeia e depois chamar o DateTimeOffset.ToUniversalTime método do objeto devolvido DateTimeOffset .
AssumeLocal Se format não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento do fuso horário local. Este é o comportamento padrão.
AssumeUniversal Se format não exigir que input contenha um valor de deslocamento, o objeto devolvido DateTimeOffset recebe o deslocamento UTC (+00:00).
AllowInnerWhite Permite input incluir espaço em branco interno não especificado pelo formato. Pode surgir espaço em branco extra entre componentes de data e hora e dentro de componentes individuais, exceto o deslocamento, sendo ignorado ao analisar a cadeia.
AllowLeadingWhite Permite input incluir espaços à frente não especificados por format. Estas são ignoradas ao analisar a sequência.
AllowTrailingWhite Permite input incluir espaços finais não especificados por format. Estas são ignoradas ao analisar a sequência.
AllowWhiteSpaces Permite input incluir espaços de frente, de final e interiores não especificados por format. Todos os caracteres de espaço em branco extra não especificados em format são ignorados ao analisar a cadeia.
None Indica que não é permitido espaço em branco adicional em input. O espaço em branco deve aparecer exatamente como especificado em format. Este é o comportamento padrão.
RoundtripKind Não tem efeito, porque a DateTimeOffset estrutura não inclui uma Kind propriedade.

Notas para Chamadores

No .NET Framework 4, o TryParseExact devolve false se a cadeia a analisar contiver um componente de horas e um designador AM/PM que não estejam em concordância. No .NET Framework 3.5 e versões anteriores, o designador AM/PM é ignorado.

Ver também

Aplica-se a