DateTimeOffset.ParseExact Método

public:
 static DateTimeOffset ParseExact(System::String ^ input, cli::array <System::String ^> ^ formats, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, formats As String(), formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parâmetros

Devoluções

Um objeto que é equivalente à data e hora contidas no input parâmetro, conforme especificado pelos formatsparâmetros, formatProvider, e styles .

Exceções

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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) 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 = new 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();
   try
   {
      result = DateTimeOffset.ParseExact(input, formats, provider,
                                         DateTimeStyles.AllowWhiteSpaces);
      break;
   }
   catch (FormatException)
   {
      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 input = String.Empty
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

let mutable result = None
let mutable tries = 0
while tries < 3 && result.IsNone do
    printfn "Enter a date, time, and offset (MM/DD/YYYY HH:MM +/-HH:MM),"
    printf "Then press Enter: "
    let input = stdin.ReadLine()
    printfn ""
    try
        result <- 
            DateTimeOffset.ParseExact(input, formats, provider, DateTimeStyles.AllowWhiteSpaces) 
            |> Some
    with :? FormatException ->
        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() 
    Try
       result = DateTimeOffset.ParseExact(input, formats, provider, _
                                          DateTimeStyles.AllowWhiteSpaces)
       Exit Do
    Catch e As FormatException
       Console.WriteLine("Unable to parse {0}.", input)      
       tries += 1
    End Try
 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 DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) método analisa a representação da string de uma data que corresponde a qualquer um dos padrões atribuídos ao formats parâmetro. Se a input cadeia não corresponder a nenhum destes padrões com nenhuma das variações definidas pelo styles parâmetro, o método lança um FormatException. Para além de comparar input com múltiplos padrões de formatação, 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 um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o padrão possível do input parâmetro. Quando o método é chamado, input deve corresponder a um destes padrões. 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, o método lança um FormatException.

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 input 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 formato preciso de input, se o elemento de correspondência de formats for uma cadeia de especificador de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

• Um CultureInfo objeto que representa a cultura com base na qual input é interpretado. O DateTimeFormatInfo objeto devolvido pela CultureInfo.DateTimeFormat propriedade define os símbolos e a formatação em input.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

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 por format. Pode aparecer espaço em branco extra entre os 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 formats. Estas são ignoradas ao analisar a sequência.
AllowTrailingWhite	Permite input incluir espaços finais não especificados por formats. 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 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 conforme especificado num determinado elemento de formats para que ocorra uma correspondência. 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 método ParseExact lança um FormatException se a cadeia a analisar contiver um componente de hora 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

• TryParseExact
• Cadeias de Formatos de Data e Hora Padrão
• Cadeias de Formato de Data e Hora Personalizadas

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider, System::Globalization::DateTimeStyles styles);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles);

static member ParseExact : string * string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider, styles As DateTimeStyles) As DateTimeOffset

Parâmetros

Devoluções

Um objeto que é equivalente à data e hora contidas no input parâmetro, conforme especificado pelos formatparâmetros, formatProvider, e styles .

Exceções

Exemplos

O exemplo seguinte utiliza o DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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;
CultureInfo provider = CultureInfo.InvariantCulture;

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

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
dateString = " 06/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowTrailingWhite);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider,
                                      DateTimeStyles.AllowWhiteSpaces |
                                      DateTimeStyles.AdjustToUniversal);
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AssumeUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    printfn $"'{dateString}' is not in the correct format."

// Parse date-only value with leading white space.
// Should throw a FormatException because only trailing white space is
// specified in method call.
let dateString = " 06/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowTrailingWhite)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider, DateTimeStyles.AllowWhiteSpaces)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
try
    let result = 
        DateTimeOffset.ParseExact(dateString, format, provider,
                                  DateTimeStyles.AllowWhiteSpaces |||
                                  DateTimeStyles.AdjustToUniversal)
    printfn $"'{dateString}' converts to {result}."
with :? FormatException ->
    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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AssumeUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' Parse date-only value with leading white space.
' Should throw a FormatException because only trailing white space is  
' specified in method call.
dateString = " 06/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowTrailingWhite)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 

' 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"       
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider, _
                                      DateTimeStyles.AllowWhiteSpaces Or _
                                      DateTimeStyles.AdjustToUniversal)
   Console.WriteLine("'{0}' converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("'{0}' is not in the correct format.", dateString)
End Try 
' 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:

• contêm espaço em branco e uma flag apropriada DateTimeStyles (como a DateTimeStyles.AllowWhiteSpaces que não foi fornecida na chamada ao método).

• contêm elementos de data e hora que estão fora do alcance.

As strings que não especificam um deslocamento UTC assumem-se que têm o deslocamento do fuso horário local (neste caso, -07:00), a menos que a DateTimeStyles.AssumeUniversal flag seja fornecida na chamada ao método. Nesse caso, assume-se que são Tempo Coordenado Universal.

module parseexact_iso8601_2

open System
open System.Globalization

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

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

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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:");
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null, styles);
            Console.WriteLine($"   {dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"   FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 19:45:16 +00:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 -07:00
//         FormatException: 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
//         FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//         FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//         2018-08-18T12:45:16.0000000         --> 2018-08-18 12:45:16 +00:00
//         FormatException: 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}:")
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateString, "O", Nothing, styles)
            Console.WriteLine($"   {dateString,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         catch e As FormatException
            Console.WriteLine($"   FormatException: Unable to convert '{dateString}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      Parsing with None:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AllowWhiteSpaces:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AdjustToUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeLocal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'
'      -----
'
'      Parsing with AssumeUniversal:
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'
'         FormatException: Unable to convert '07-30-2018'

Observações

O DateTimeOffset.ParseExact(String, String, IFormatProvider, DateTimeStyles) método analisa a representação em cadeia de uma data, que deve estar no formato definido pelo format parâmetro. Também exige que os <elementos Data>, <Hora> e <Deslocamento> da representação da cadeia de uma data e hora apareçam na ordem especificada por format. Se a input cadeia não corresponder ao padrão do format parâmetro, com quaisquer variações definidas pelo styles parâmetro, o método gera um FormatException. Em contraste, o DateTimeOffset.Parse(String, IFormatProvider, DateTimeStyles) método analisa a representação da string de uma data em qualquer um dos formatos reconhecidos pelo objeto do DateTimeFormatInfo fornecedor de formatos. Parse também permite que os <elementos Data>, <Hora> e <Deslocamento> da representação da string de uma data e hora apareçam em qualquer ordem.

O format parâmetro é uma cadeia que contém um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o padrão requerido do input parâmetro. 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, o método lança um FormatException.

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 formato preciso de input, se format for uma cadeia de especificação de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

• Um CultureInfo objeto que representa a cultura com base na qual input é interpretado. O DateTimeFormatInfo objeto devolvido pela CultureInfo.DateTimeFormat propriedade define os símbolos e a formatação em input.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

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 valor 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ços em branco internos não especificados por format. Pode surgir espaço em branco extra entre componentes de data e hora e dentro de componentes individuais, 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 método ParseExact lança um FormatException se a cadeia a analisar contiver um componente de hora 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

• TryParseExact
• Cadeias de Formatos de Data e Hora Padrão
• Cadeias de Formato de Data e Hora Personalizadas

public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), format As ReadOnlySpan(Of Char), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parâmetros

Devoluções

Um objeto que é equivalente à data e hora contidas no input parâmetro, conforme especificado pelos formatparâmetros, formatProvider, e styles .

Exceções

Observações

Este método analisa um intervalo de caracteres que representa uma data, que deve estar no formato definido pelo format parâmetro. Também exige que os <elementos Data>, <Hora> e <Deslocamento> da representação da cadeia de uma data e hora apareçam na ordem especificada por format. Se input não corresponder ao format padrão, o método gera um FormatException. Em contraste, o DateTimeOffset.Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) método analisa a representação da string de uma data em qualquer um dos formatos reconhecidos pelo objeto do DateTimeFormatInfo fornecedor de formatos. Parse também permite que os <elementos Data>, <Hora> e <Deslocamento> da representação da string de uma data e hora apareçam em qualquer ordem.

O format parâmetro é um intervalo de caracteres que contém um especificador de formato padrão de um único carácter ou um ou mais especificadores de formato personalizados que definem o formato exigido do input parâmetro. 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, o método lança um FormatException.

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 contenha um deslocamento, o objeto resultante DateTimeOffset é-lhe atribuído o deslocamento do fuso horário do sistema local.

Os símbolos e strings de data e hora usados em input são definidos pelo formatProvider parâmetro, assim como o formato preciso de input se format for um especificador de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

• Um CultureInfo objeto que representa a cultura com base na qual input é interpretado. O DateTimeFormatInfo objeto devolvido pela sua DateTimeFormat propriedade define os símbolos e a formatação em input.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

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

public:
 static DateTimeOffset ParseExact(System::String ^ input, System::String ^ format, IFormatProvider ^ formatProvider);

public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider);

static member ParseExact : string * string * IFormatProvider -> DateTimeOffset

Public Shared Function ParseExact (input As String, format As String, formatProvider As IFormatProvider) As DateTimeOffset

Parâmetros

Devoluções

Um objeto que é equivalente à data e hora contidas em input conforme especificado por format e formatProvider.

Exceções

Exemplos

O exemplo seguinte utiliza o DateTimeOffset.ParseExact(String, String, IFormatProvider) método com especificadores de formato padrão e personalizados e a cultura invariante para analisar várias cadeias de data e hora.

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

// Parse date-only value with invariant culture.
dateString = "06/15/2008";
format = "d";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
dateString = "6/15/2008";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00";
format = "ddd dd MMM yyyy h:mm tt zzz";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   Console.WriteLine("{0} is not in the correct format.", dateString);
}

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06";
try
{
   result = DateTimeOffset.ParseExact(dateString, format, provider);
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString());
}
catch (FormatException)
{
   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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

let provider = CultureInfo.InvariantCulture

// Parse date-only value with invariant culture.
let dateString = "06/15/2008"
let format = "d"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date-only value without leading zero in month using "d" format.
// Should throw a FormatException because standard short date pattern of
// invariant culture requires two-digit month.
let dateString = "6/15/2008"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with custom specifier.
let dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
let format = "ddd dd MMM yyyy h:mm tt zzz"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    printfn $"{dateString} is not in the correct format."

// Parse date and time with offset without offset//s minutes.
// Should throw a FormatException because "zzz" specifier requires leading
// zero in hours.
let dateString = "Sun 15 Jun 2008 8:30 AM -06"
try
    let result = DateTimeOffset.ParseExact(dateString, format, provider)
    printfn $"{dateString} converts to {result}."
with :? FormatException ->
    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 -07:00.
//    6/15/2008 is not in the correct format.
//    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
//    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

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

' Parse date-only value with invariant culture.
dateString = "06/15/2008"
format = "d"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date-only value without leading zero in month using "d" format.
' Should throw a FormatException because standard short date pattern of 
' invariant culture requires two-digit month.
dateString = "6/15/2008"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with custom specifier.
dateString = "Sun 15 Jun 2008 8:30 AM -06:00"
format = "ddd dd MMM yyyy h:mm tt zzz"        
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 

' Parse date and time with offset without offset's minutes.
' Should throw a FormatException because "zzz" specifier requires leading  
' zero in hours.
dateString = "Sun 15 Jun 2008 8:30 AM -06"
Try
   result = DateTimeOffset.ParseExact(dateString, format, provider)
   Console.WriteLine("{0} converts to {1}.", dateString, result.ToString())
Catch e As FormatException
   Console.WriteLine("{0} is not in the correct format.", dateString)
End Try 
' The example displays the following output:
'    06/15/2008 converts to 6/15/2008 12:00:00 AM -07:00.
'    6/15/2008 is not in the correct format.
'    Sun 15 Jun 2008 8:30 AM -06:00 converts to 6/15/2008 8:30:00 AM -06:00.
'    Sun 15 Jun 2008 8:30 AM -06 is not in the correct format.

O exemplo seguinte analisa um array de cadeias que se espera que cumpram a ISO 8601. Como a saída do exemplo mostra, cadeias com espaços à frente ou à saída falham em analisar com sucesso, tal como as cadeias com elementos de data e hora fora do intervalo.

module parseexact_iso8601

open System

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.0000000Z "
      "2018-08-18T12:45:16.0000000+02:00"
      "2018-08-18T12:45:16.0000000-07:00" ]

for dateString in dateStrings do
    try
        let date =
            DateTimeOffset.ParseExact(dateString, "O", null)

        printfn $"""{dateString, -35} --> {date.ToString "yyyy-MM-dd HH:mm:ss.FF zzz"}"""
    with :? FormatException -> printfn $"FormatException: Unable to convert '{dateString}'"


// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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;

public class Example2
{
   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.0000000Z ",
                               "2018-08-18T12:45:16.0000000+02:00",
                               "2018-08-18T12:45:16.0000000-07:00" }; 
      
      foreach (var dateString in dateStrings)
      {
         try {
            var date = DateTimeOffset.ParseExact(dateString, "O", null);
            Console.WriteLine($"{dateString,-35} --> {date:yyyy-MM-dd HH:mm:ss.FF zzz}");
         }
         catch (FormatException)
         {
            Console.WriteLine($"FormatException: Unable to convert '{dateString}'");
         }   
      } 
   }
}
// The example displays the following output:
//      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
//      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
//      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
//      FormatException: 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

Public Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "2018-08-18T12:45:16.0000000Z",
                                      "2018/08/18T12:45:16.0000000Z",
                                      "2018-18-08T12:45:16.0000000Z",
                                      " 2018-08-18T12:45:16.0000000Z ",
                                      "2018-08-18T12:45:16.0000000+02:00",
                                      "2018-08-18T12:45:16.0000000-07:00" } 
      
      For Each dateStr In dateStrings
         Try 
            Dim dat = DateTimeOffset.ParseExact(dateStr, "O", Nothing)
            Console.WriteLine($"{dateStr,-35} --> {dat:yyyy-MM-dd HH:mm:ss.FF zzz}")
         Catch  e As FormatException
            Console.WriteLine($"FormatException: Unable to convert '{dateStr}'")
         End Try   
      Next 
   End Sub
End Module
' The example displays the following output:
'      2018-08-18T12:45:16.0000000Z        --> 2018-08-18 12:45:16 +00:00
'      FormatException: Unable to convert '2018/08/18T12:45:16.0000000Z'
'      FormatException: Unable to convert '2018-18-08T12:45:16.0000000Z'
'      FormatException: 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

O ParseExact(String, String, IFormatProvider) método analisa a representação em cadeia de uma data, que deve estar no formato definido pelo format parâmetro. Também exige que os <elementos Data>, <Hora> e <Deslocamento> da representação da cadeia de uma data e hora apareçam na ordem especificada por format. Se a input cadeia não corresponder a este format parâmetro, o método gera um FormatException. Em contraste, o DateTimeOffset.Parse(String, IFormatProvider) método analisa a representação da string de uma data em qualquer um dos formatos reconhecidos pelo objeto do DateTimeFormatInfo fornecedor de formatos. Parse também permite que os <elementos Data>, <Hora> e <Deslocamento> da representação da string de uma data e hora apareçam em qualquer ordem.

O format parâmetro é uma cadeia que contém um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o formato necessário do input parâmetro. 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, o método lança um FormatException.

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 contenha um deslocamento, o objeto resultante DateTimeOffset é-lhe atribuído o deslocamento do fuso horário do sistema local.

Os símbolos e strings de data e hora usados em input são definidos pelo formatProvider parâmetro, assim como o formato preciso de input se format for uma string de especificador de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

• Um CultureInfo objeto que representa a cultura com base na qual input é interpretado. O DateTimeFormatInfo objeto devolvido pela sua DateTimeFormat propriedade define os símbolos e a formatação em input.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

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

Notas para Chamadores

No .NET Framework 4, o método ParseExact lança um FormatException se a cadeia a analisar contiver um componente de hora 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

• TryParseExact
• Cadeias de Formatos de Data e Hora Padrão
• Cadeias de Formato de Data e Hora Personalizadas

public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);

static member ParseExact : ReadOnlySpan<char> * string[] * IFormatProvider * System.Globalization.DateTimeStyles -> DateTimeOffset

Public Shared Function ParseExact (input As ReadOnlySpan(Of Char), formats As String(), formatProvider As IFormatProvider, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTimeOffset

Parâmetros

Devoluções

Um objeto que é equivalente à data e hora contidas no input parâmetro, conforme especificado pelos formatsparâmetros, formatProvider, e styles .

Exceções

Observações

Este método analisa um intervalo de caracteres que representa uma data que corresponde a qualquer um dos padrões atribuídos ao formats parâmetro. Se input não corresponder a nenhum destes padrões com nenhuma das variações definidas pelo styles parâmetro, o método gera um FormatException. Para além de comparar input com múltiplos padrões de formatação, esta sobrecarga comporta-se de forma idêntica ao DateTimeOffset.ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) método.

O formats parâmetro é um array de strings cujos elementos contêm um único especificador de formato padrão ou um ou mais especificadores de formato personalizados que definem o padrão possível do input parâmetro. Quando o método é chamado, input deve corresponder a um destes padrões. 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, o método lança um FormatException.

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 input 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 formato preciso de input, se o elemento de correspondência de formats for uma cadeia de especificador de formato padrão. O formatProvider parâmetro pode ser um dos seguintes:

• Um CultureInfo objeto que representa a cultura com base na qual input é interpretado. O DateTimeFormatInfo objeto devolvido pela CultureInfo.DateTimeFormat propriedade define os símbolos e a formatação em input.

• Um DateTimeFormatInfo objeto que define o formato dos dados de data e hora.

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 por format. Pode aparecer espaço em branco extra entre os 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 formats. Estas são ignoradas ao analisar a sequência.
AllowTrailingWhite	Permite input incluir espaços finais não especificados por formats. 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 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 conforme especificado num determinado elemento de formats para que ocorra uma correspondência. Este é o comportamento padrão.
RoundtripKind	Não tem efeito porque a DateTimeOffset estrutura não inclui uma Kind propriedade.