DateTime.Parse Método

Definição

Converte a representação da cadeia de caracteres de uma data e hora ao seu equivalente DateTime.

Sobrecargas

Parse(String)

Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as convenções da cultura atual.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analisa um intervalo de caracteres em um valor.

Parse(String, IFormatProvider)

Converte a representação da cadeia de caracteres de uma data e hora em seu equivalente DateTime usando as informações de formato específicas da cultura.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Converte um intervalo de memória que contém uma representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as informações de formato e um estilo de formatação específicos da cultura.

Parse(String, IFormatProvider, DateTimeStyles)

Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as informações de formato e um estilo de formatação específicos da cultura.

Exemplos

Vários exemplos que chamam o DateTime.Parse método são intercalados em toda a seção Comentários deste artigo e na documentação para as sobrecargas individuais DateTime.Parse .

Observação

Alguns exemplos de C# neste artigo são executados no playground e no executador de código embutido Try.NET. Clique no botão Executar para executar um exemplo em uma janela interativa. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.

O fuso horário local do executador de código embutido Try.NET e do playground é o Tempo Universal Coordenado ou UTC. Isso pode afetar o comportamento e a saída dos exemplos que ilustram os tipos DateTime, DateTimeOffset e TimeZoneInfo e seus membros.

Você também pode baixar um conjunto completo de DateTime.Parse exemplos, que estão incluídos em um projeto do .NET Core para C#.

Comentários

Nesta seção:

Qual método devo chamar?

Para Chamar
Analise uma cadeia de caracteres de data e hora usando as convenções da cultura atual. sobrecarga de Parse(String)
Analise uma cadeia de caracteres de data e hora usando as convenções de uma cultura específica. Parse(String, IFormatProvider) sobrecarga (consulte Análise e Convenções Culturais)
Analise uma cadeia de caracteres de data e hora com elementos de estilo especiais (como espaço em branco ou sem espaço em branco). sobrecarga de Parse(String, IFormatProvider, DateTimeStyles)
Analise uma cadeia de caracteres de data e hora que deve estar em um formato específico. DateTime.ParseExact ou DateTime.TryParseExact
Analise uma cadeia de caracteres de data e hora e execute uma conversão em UTC ou hora local. sobrecarga de Parse(String, IFormatProvider, DateTimeStyles)
Analise uma cadeia de caracteres de data e hora sem lidar com exceções. Método DateTime.TryParse
Restaure (ida e volta) um valor de data e hora criado por uma operação de formatação. Passe a cadeia de caracteres de formato padrão "o" ou "r" para o ToString(String) método e chame a Parse(String, IFormatProvider, DateTimeStyles) sobrecarga com DateTimeStyles.RoundtripKind
Analise uma cadeia de caracteres de data e hora em um formato fixo entre limites de máquina (e possivelmente culturais). DateTime.ParseExactmétodo ou DateTime.TryParseExact

A cadeia de caracteres a ser analisada

O Parse método tenta converter a representação de cadeia de caracteres de um valor de data e hora em seu DateTime equivalente. Ele tenta analisar a cadeia de caracteres de entrada completamente sem gerar uma FormatException exceção.

Importante

Se a operação de análise falhar devido a um formato de cadeia de caracteres não reconhecido, o Parse método gerará um FormatException, enquanto o TryParse método retornará false. Como o tratamento de exceções pode ser caro, você deve usar Parse quando espera-se que a operação de análise seja bem-sucedida porque a fonte de entrada é confiável. TryParse é preferível quando falhas de análise são prováveis, especialmente porque uma fonte de entrada não é confiável ou você tem valores padrão razoáveis para substituir por cadeias de caracteres que não são analisadas com êxito.

A cadeia de caracteres a ser analisada pode usar qualquer uma das seguintes formas:

  • Uma cadeia de caracteres com um componente de data e hora.

  • Uma cadeia de caracteres com um componente de data, mas sem hora. Se o componente de hora estiver ausente, o método assumirá 12:00 meia-noite. Se o componente de data tiver um ano de dois dígitos, ele será convertido em um ano com base no Calendar.TwoDigitYearMax calendário atual da cultura atual ou no calendário atual da cultura especificada (se você usar uma sobrecarga com um argumento não nulo provider ).

  • Uma cadeia de caracteres com um componente de data que inclui apenas o mês e o ano, mas nenhum componente de dia. O método pressupõe o primeiro dia do mês.

  • Uma cadeia de caracteres com um componente de data que inclui apenas o mês e o dia, mas nenhum componente de ano. O método pressupõe o ano atual.

  • Uma cadeia de caracteres com um componente de hora, mas sem data. O método pressupõe a data atual, a menos que você chame a Parse(String, IFormatProvider, DateTimeStyles) sobrecarga e inclua DateTimeStyles.NoCurrentDateDefault no styles argumento , caso em que o método assume uma data de 1º de janeiro de 0001.

  • Uma cadeia de caracteres com um componente de hora que inclui apenas a hora e um designador AM/PM, sem componente de data. O método pressupõe a data atual e uma hora sem minutos e sem segundos. Você pode alterar esse comportamento chamando a Parse(String, IFormatProvider, DateTimeStyles) sobrecarga e incluir DateTimeStyles.NoCurrentDateDefault no styles argumento ; nesse caso, o método pressupõe uma data de 1º de janeiro de 0001.

  • Uma cadeia de caracteres que inclui informações de fuso horário e está em conformidade com a ISO 8601. Nos exemplos a seguir, a primeira cadeia de caracteres designa UTC (Tempo Universal Coordenado) e a segunda designa a hora em um fuso horário sete horas antes do UTC:

    "2008-11-01T19:35:00.0000000Z" "2008-11-01T19:35:00.00000000-07:00"

  • Uma cadeia de caracteres que inclui o designador GMT e está em conformidade com o formato de hora RFC 1123; por exemplo:

    "Sáb, 01 nov 2008 19:35:00 GMT"

  • Uma cadeia de caracteres que inclui a data e a hora, juntamente com as informações de deslocamento de fuso horário; por exemplo:

    "03/01/2009 05:42:00 -5:00"

O exemplo a seguir analisa cadeias de caracteres em cada um desses formatos usando as convenções de formatação da cultura atual, que nesse caso é a cultura en-US:

using System;

public class Example
{
   public static void Main()
   {
      (string dateAsString, string description)[]  dateInfo = { ("08/18/2018 07:22:16", "String with a date and time component"),
                                                                ("08/18/2018", "String with a date component only"),
                                                                ("8/2018", "String with a month and year component only"),
                                                                ("8/18", "String with a month and day component only"),
                                                                ("07:22:16", "String with a time component only"),
                                                                ("7 PM", "String with an hour and AM/PM designator only"),
                                                                ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),
                                                                ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                                                                ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                                                                ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) };

      Console.WriteLine($"Today is {DateTime.Now:d}\n");

      foreach (var item in dateInfo) {
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}");
      }
   }
}
// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM
module Parse6

open System

let  dateInfo = 
    [ "08/18/2018 07:22:16", "String with a date and time component"
      "08/18/2018", "String with a date component only"
      "8/2018", "String with a month and year component only"
      "8/18", "String with a month and day component only"
      "07:22:16", "String with a time component only"
      "7 PM", "String with an hour and AM/PM designator only"
      "2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"
      "2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"
      "Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"
      "08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ]

printfn $"Today is {DateTime.Now:d}\n"

for dateAsString, description in dateInfo do
    printfn $"""{description + ":",-52} '{dateAsString}' --> {DateTime.Parse(dateAsString)}"""


// The example displays output like the following:
//   Today is 2/22/2018
//
//   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
//   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
//   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
//   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
//   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
//   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
//   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
//   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
//   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
//   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Public Module Strings
   Public Sub Main()
      Dim dateInfo() As (dateAsString As String, description As String) = 
                     { ("08/18/2018 07:22:16", "String with a date and time component"),
                       ("08/18/2018", "String with a date component only"),
                       ("8/2018", "String with a month and year component only"),
                       ("8/18", "String with a month and day component only"),
                       ("07:22:16", "String with a time component only"),
                       ("7 PM", "String with an hour and AM/PM designator only"),
                       ("2018-08-18T07:22:16.0000000Z", "UTC string that conforms to ISO 8601"),   
                       ("2018-08-18T07:22:16.0000000-07:00", "Non-UTC string that conforms to ISO 8601"),
                       ("Sat, 18 Aug 2018 07:22:16 GMT", "String that conforms to RFC 1123"),
                       ("08/18/2018 07:22:16 -5:00", "String with date, time, and time zone information" ) }
   
      Console.WriteLine($"Today is {Date.Now:d}{vbCrLf}")
      
      For Each item in dateInfo
         Console.WriteLine($"{item.description + ":",-52} '{item.dateAsString}' --> {DateTime.Parse(item.dateAsString)}")        
      Next
   End Sub
End Module
' The example displays output like the following:
'   Today is 2/22/2018
'   
'   String with a date and time component:               '08/18/2018 07:22:16' --> 8/18/2018 7:22:16 AM
'   String with a date component only:                   '08/18/2018' --> 8/18/2018 12:00:00 AM
'   String with a month and year component only:         '8/2018' --> 8/1/2018 12:00:00 AM
'   String with a month and day component only:          '8/18' --> 8/18/2018 12:00:00 AM
'   String with a time component only:                   '07:22:16' --> 2/22/2018 7:22:16 AM
'   String with an hour and AM/PM designator only:       '7 PM' --> 2/22/2018 7:00:00 PM
'   UTC string that conforms to ISO 8601:                '2018-08-18T07:22:16.0000000Z' --> 8/18/2018 12:22:16 AM
'   Non-UTC string that conforms to ISO 8601:            '2018-08-18T07:22:16.0000000-07:00' --> 8/18/2018 7:22:16 AM
'   String that conforms to RFC 1123:                    'Sat, 18 Aug 2018 07:22:16 GMT' --> 8/18/2018 12:22:16 AM
'   String with date, time, and time zone information:   '08/18/2018 07:22:16 -5:00' --> 8/18/2018 5:22:16 AM

Se a cadeia de caracteres de entrada representar um dia bissexto em um ano bissexto no calendário usado pelo método de análise (consulte Convenções culturais e de análise), o Parse método analisará a cadeia de caracteres com êxito. Se a cadeia de caracteres de entrada representar um dia bissexto em um ano não bissexto, o método gerará um FormatException.

Como o Parse método tenta analisar a representação de cadeia de caracteres de uma data e hora usando as regras de formatação da cultura atual ou especificada, a tentativa de analisar uma cadeia de caracteres entre diferentes culturas pode falhar. Para analisar um formato de data e hora específico em diferentes localidades, use uma das sobrecargas do DateTime.ParseExact método e forneça um especificador de formato.

Convenções de análise e culturais

Todas as sobrecargas do Parse método diferenciam a cultura, a menos que a cadeia de caracteres a ser analisada (representada por s na tabela a seguir) esteja em conformidade com o padrão ISO 8601. A operação de análise usa as informações de formatação em um DateTimeFormatInfo objeto derivado da seguinte maneira:

Importante

As eras nos calendários japoneses se baseiam no reinado do Imperador e, portanto, estão sujeitas a alterações. Por exemplo, 1º de maio de 2019 marcou o início da era Reiwa no JapaneseCalendar e no JapaneseLunisolarCalendar. Tal alteração de eras afeta todos os aplicativos que usam esses calendários. Para obter mais informações e determinar se seus aplicativos são afetados, consulte Manipulando uma nova era no calendário japonês no .NET. Para obter informações sobre como testar seus aplicativos em sistemas Windows para garantir sua preparação para a alteração da era, consulte Preparar seu aplicativo para a alteração da era japonesa. Para recursos no .NET que dão suporte a calendários com várias eras e para práticas recomendadas ao trabalhar com calendários que dão suporte a várias eras, consulte Trabalhando com eras.

Se você chamar E provider for As informações de formatação são derivadas de
Parse(String) - A cultura atual (DateTimeFormatInfo.CurrentInfo propriedade)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles) um DateTimeFormatInfo objeto O objeto especificado DateTimeFormatInfo
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles) null A cultura atual (DateTimeFormatInfo.CurrentInfo propriedade)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles) um CultureInfo objeto A propriedade CultureInfo.DateTimeFormat
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles) Implementação personalizada IFormatProvider O método IFormatProvider.GetFormat

Quando as informações de formatação são derivadas de um DateTimeFormatInfo objeto , a DateTimeFormatInfo.Calendar propriedade define o calendário usado na operação de análise.

Se você analisar uma cadeia de caracteres de data e hora usando um DateTimeFormatInfo objeto com configurações personalizadas diferentes daquelas de uma cultura padrão, use o ParseExact método em vez do Parse método para melhorar as chances de uma conversão bem-sucedida. Uma cadeia de caracteres de data e hora não padrão pode ser complicada e difícil de analisar. O Parse método tenta analisar uma cadeia de caracteres com vários padrões de análise implícitos, que podem falhar. Por outro lado, o ParseExact método exige que você designe explicitamente um ou mais padrões de análise exatos que provavelmente serão bem-sucedidos. Para obter mais informações, consulte a seção "DateTimeFormatInfo and Dynamic Data" no DateTimeFormatInfo tópico.

Importante

Observe que as convenções de formatação para uma cultura específica são dinâmicas e podem estar sujeitas a alterações. Isso significa que as operações de análise que dependem das convenções de formatação da cultura padrão (atual) ou que especificam um IFormatProvider objeto que representa uma cultura diferente da cultura invariável poderão falhar inesperadamente se qualquer uma das seguintes opções ocorrer:

  • Os dados específicos da cultura foram alterados entre as versões principais ou secundárias do .NET Framework ou como resultado de uma atualização para a versão existente do .NET Framework.
  • Os dados específicos da cultura refletem as preferências do usuário, que podem variar de computador para computador ou sessão para sessão.
  • Os dados específicos da cultura representam uma cultura de substituição que substitui as configurações de uma cultura padrão ou de uma cultura personalizada.

Para evitar as dificuldades na análise de dados e cadeias de caracteres de tempo associadas a alterações nos dados culturais, você pode analisar cadeias de caracteres de data e hora usando a cultura invariável ou chamar o ParseExact método ou TryParseExact e especificar o formato exato da cadeia de caracteres a ser analisada. Se você estiver serializando e desserializando dados de data e hora, poderá usar as convenções de formatação da cultura invariável ou serializar e desserializar o DateTime valor em um formato binário.

Para obter mais informações, consulte a seção "Dados de cultura dinâmica" no CultureInfo tópico e a seção "Valores de DateTime persistentes" no DateTime tópico.

Elementos de análise e estilo

Todas as Parse sobrecargas ignoram caracteres de espaço em branco à esquerda, internos ou à direita na cadeia de caracteres de entrada (que é representada por s na tabela a seguir). A data e a hora podem ser entre colchetes com um par de caracteres NUMBER SIGN à esquerda e à direita ("#", U+0023) e podem ser seguidos com um ou mais caracteres NULL (U+0000).

Além disso, a Parse(String, IFormatProvider, DateTimeStyles) sobrecarga tem um styles parâmetro que consiste em um ou mais membros da DateTimeStyles enumeração . Esse parâmetro define como s deve ser interpretado e como a operação de análise deve ser convertida s em uma data e hora. A tabela a seguir descreve o efeito de cada DateTimeStyles membro na operação de análise.

Membro DateTimeStyles Efeito na conversão
AdjustToUniversal s Analisa e, se necessário, converte-o em UTC, da seguinte maneira:

- Se s incluir um deslocamento de fuso horário ou se s não contiver nenhuma informação de fuso horário, mas styles incluir o AssumeLocal sinalizador , o método analisará a cadeia de caracteres, chamará ToUniversalTime para converter o valor retornado DateTime em UTC e definirá a Kind propriedade como DateTimeKind.Utc.
- Se s indicar que ele representa UTC ou se s não contiver informações de fuso horário, mas styles incluir o AssumeUniversal sinalizador , o método analisará a cadeia de caracteres, não executará nenhuma conversão de fuso horário no valor retornado DateTime e definirá a Kind propriedade como DateTimeKind.Utc.
- Em todos os outros casos, o sinalizador não tem efeito.
AllowInnerWhite Este valor é ignorado. O espaço em branco interno sempre é permitido nos elementos de data e hora de s.
AllowLeadingWhite Este valor é ignorado. O espaço em branco à esquerda é sempre permitido nos elementos de data e hora de s.
AllowTrailingWhite Este valor é ignorado. O espaço em branco à direita sempre é permitido nos elementos de data e hora de s.
AllowWhiteSpaces Especifica que s podem conter espaços em branco à esquerda, internos e à direita. Esse é o comportamento padrão. Ele não pode ser substituído fornecendo um valor de enumeração mais restritivo DateTimeStyles , como None.
AssumeLocal Especifica que, se s não houver informações de fuso horário, a hora local será assumida. A menos que o sinalizador AdjustToUniversal esteja presente, a propriedade Kind do valor DateTime retornado é definida como DateTimeKind.Local.
AssumeUniversal Especifica que, se s não houver informações de fuso horário, o UTC será assumido. A menos que o sinalizador AdjustToUniversal esteja presente, o método converte o valor DateTime retornado do UTC na hora local e define a propriedade Kind como DateTimeKind.Local.
None Embora válido, esse valor é ignorado.
RoundtripKind Para cadeias de caracteres que contêm informações de fuso horário, tenta impedir a conversão de uma cadeia de caracteres de data e hora em um DateTime valor que representa uma hora local com sua Kind propriedade definida DateTimeKind.Localcomo . Normalmente, essa cadeia de caracteres é criada chamando o DateTime.ToString(String) método e usando o especificador de formato padrão "o", "r" ou "u".

O valor retornado e DateTime.Kind

As DateTime.Parse sobrecargas retornam um DateTime valor cuja Kind propriedade inclui informações de fuso horário. Ele pode indicar que a hora é:

Em geral, o Parse método retorna um DateTime objeto cuja Kind propriedade é DateTimeKind.Unspecified. No entanto, o Parse método também pode executar a conversão de fuso horário e definir o valor da propriedade de Kind maneira diferente, dependendo dos valores dos s parâmetros e styles :

If Conversão de fuso horário Propriedade de tipo
s contém informações de fuso horário. A data e a hora são convertidas na hora no fuso horário local. DateTimeKind.Local
s contém informações de fuso horário e styles inclui o AdjustToUniversal sinalizador . A data e a hora são convertidas em UTC (Tempo Universal Coordenado). DateTimeKind.Utc
s contém o designador de fuso horário Z ou GMT e styles inclui o RoundtripKind sinalizador . A data e a hora são interpretadas como UTC. DateTimeKind.Utc

O exemplo a seguir converte cadeias de caracteres de data que contêm informações de fuso horário para a hora no fuso horário local:

using System;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = {"2008-05-01T07:34:42-5:00",
                              "2008-05-01 7:34:42Z",
                              "Thu, 01 May 2008 07:34:42 GMT"};
      foreach (string dateString in dateStrings)
      {
         DateTime convertedDate = DateTime.Parse(dateString);
         Console.WriteLine($"Converted {dateString} to {convertedDate.Kind} time {convertedDate}");
      }
   }
}
// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM
open System

let dateStrings = 
    [ "2008-05-01T07:34:42-5:00"
      "2008-05-01 7:34:42Z"
      "Thu, 01 May 2008 07:34:42 GMT" ]

for dateString in dateStrings do
    let convertedDate = DateTime.Parse dateString
    printfn $"Converted {dateString} to {convertedDate.Kind} time {convertedDate}"

// These calls to the DateTime.Parse method display the following output:
//  Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
//  Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
//  Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM
Module Example
   Public Sub Main()
      Dim dateStrings() As String = {"2008-05-01T07:34:42-5:00", 
                                     "2008-05-01 7:34:42Z", 
                                     "Thu, 01 May 2008 07:34:42 GMT"}
      
      For Each dateStr In dateStrings
         Dim convertedDate As Date = Date.Parse(dateStr)
         Console.WriteLine($"Converted {dateStr} to {convertedDate.Kind} time {convertedDate}")
      Next 
   End Sub
End Module
' These calls to the DateTime.Parse method display the following output:
'   Converted 2008-05-01T07:34:42-5:00 to Local time 5/1/2008 5:34:42 AM
'   Converted 2008-05-01 7:34:42Z to Local time 5/1/2008 12:34:42 AM
'   Converted Thu, 01 May 2008 07:34:42 GMT to Local time 5/1/2008 12:34:42 AM

Você também pode preservar o valor de uma propriedade de Kind data e hora durante uma operação de formatação e análise usando o DateTimeStyles.RoundtripKind sinalizador . O exemplo a seguir ilustra como o RoundtripKind sinalizador afeta a operação de análise em valores convertidos em DateTime cadeias de caracteres usando o especificador de formato "o", "r" ou "u".

   string[] formattedDates = { "2008-09-15T09:30:41.7752486-07:00",
                               "2008-09-15T09:30:41.7752486Z",
                               "2008-09-15T09:30:41.7752486",
                               "2008-09-15T09:30:41.7752486-04:00",
                               "Mon, 15 Sep 2008 09:30:41 GMT" };
   foreach (string formattedDate in formattedDates)
   {
      Console.WriteLine(formattedDate);
      DateTime roundtripDate = DateTime.Parse(formattedDate, null,
                                              DateTimeStyles.RoundtripKind);
      Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.");

      DateTime noRoundtripDate = DateTime.Parse(formattedDate, null,
                                                DateTimeStyles.None);
      Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.");
   }
// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
let formattedDates = 
    [ "2008-09-15T09:30:41.7752486-07:00"
      "2008-09-15T09:30:41.7752486Z"
      "2008-09-15T09:30:41.7752486"
      "2008-09-15T09:30:41.7752486-04:00"
      "Mon, 15 Sep 2008 09:30:41 GMT" ]

for formattedDate in formattedDates do
    printfn $"{formattedDate}"
    let roundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.RoundtripKind)
    printfn $"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time."

    let noRoundtripDate = DateTime.Parse(formattedDate, null, DateTimeStyles.None)
    printfn $"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time."

// The example displays the following output:
//       2008-09-15T09:30:41.7752486-07:00
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486Z
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
//       2008-09-15T09:30:41.7752486
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
//       2008-09-15T09:30:41.7752486-04:00
//          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
//       Mon, 15 Sep 2008 09:30:41 GMT
//          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
//          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
Dim formattedDates() = { "2008-09-15T09:30:41.7752486-07:00", 
                           "2008-09-15T09:30:41.7752486Z",  
                           "2008-09-15T09:30:41.7752486",  
                           "2008-09-15T09:30:41.7752486-04:00", 
                           "Mon, 15 Sep 2008 09:30:41 GMT" }
For Each formattedDate In formattedDates
   Console.WriteLine(formattedDate)
   Dim roundtripDate = DateTime.Parse(formattedDate, Nothing,  
                                      DateTimeStyles.RoundtripKind)                        
   Console.WriteLine($"   With RoundtripKind flag: {roundtripDate} {roundtripDate.Kind} time.")                                          
   Dim noRoundtripDate = DateTime.Parse(formattedDate, Nothing,                                                                                                  DateTimeStyles.None)
   Console.WriteLine($"   Without RoundtripKind flag: {noRoundtripDate} {noRoundtripDate.Kind} time.")
Next         
' The example displays the following output:
'       2008-09-15T09:30:41.7752486-07:00
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486Z
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.
'       2008-09-15T09:30:41.7752486
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'          Without RoundtripKind flag: 9/15/2008 9:30:41 AM Unspecified time.
'       2008-09-15T09:30:41.7752486-04:00
'          With RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'          Without RoundtripKind flag: 9/15/2008 6:30:41 AM Local time.
'       Mon, 15 Sep 2008 09:30:41 GMT
'          With RoundtripKind flag: 9/15/2008 9:30:41 AM Utc time.
'          Without RoundtripKind flag: 9/15/2008 2:30:41 AM Local time.

Parse(String)

Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as convenções da cultura atual.

public:
 static DateTime Parse(System::String ^ s);
public static DateTime Parse (string s);
static member Parse : string -> DateTime
Public Shared Function Parse (s As String) As DateTime

Parâmetros

s
String

Uma cadeia de caracteres que contém uma data e hora a ser convertida. Confira a cadeia de caracteres a ser analisada para obter mais informações.

Retornos

Um objeto equivalente à data e hora contida no s.

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.

Exemplos

O exemplo a seguir analisa a representação de cadeia de caracteres de vários valores de data e hora:

  • Usando o provedor de formato padrão, que fornece as convenções de formatação da cultura atual do computador usado para produzir a saída de exemplo. A saída deste exemplo reflete as convenções de formatação da cultura en-US.

  • Usando o valor de estilo padrão, que é AllowWhiteSpaces.

Ele manipula a FormatException exceção gerada quando o método tenta analisar a representação de cadeia de caracteres de uma data e hora usando algumas outras convenções de formatação de cultura. Ele também mostra como analisar com êxito um valor de data e hora que não usa as convenções de formatação da cultura atual.

using System;
using System.Globalization;

public class DateTimeParser
{
   public static void Main()
   {
      // Assume the current culture is en-US.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      // Use standard en-US date and time value
      DateTime dateValue;
      string dateString = "2/16/2008 12:15:12 PM";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Reverse month and day to conform to the fr-FR culture.
      // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Call another overload of Parse to successfully convert string
      // formatted according to conventions of fr-FR culture.
      try {
         dateValue = DateTime.Parse(dateString, new CultureInfo("fr-FR", false));
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }

      // Parse string with date but no time component.
      dateString = "2/16/2008";
      try {
         dateValue = DateTime.Parse(dateString);
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue);
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert '{0}'.", dateString);
      }
   }
}
// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.
open System
open System.Globalization

[<EntryPoint>]
let main _ =
    // Assume the current culture is en-US.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

    // Use standard en-US date and time value
    let dateString = "2/16/2008 12:15:12 PM"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Reverse month and day to conform to the fr-FR culture.
    // The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
    let dateString = "16/02/2008 12:15:12"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        Console.WriteLine("Unable to convert '{0}'.", dateString)

    // Call another overload of Parse to successfully convert string
    // formatted according to conventions of fr-FR culture.
    try
        let dateValue = DateTime.Parse(dateString, CultureInfo("fr-FR", false))
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    // Parse string with date but no time component.
    let dateString = "2/16/2008"
    try
        let dateValue = DateTime.Parse dateString
        printfn $"'{dateString}' converted to {dateValue}."
    with :? FormatException ->
        printfn $"Unable to convert '{dateString}'."

    0

// The example displays the following output to the console:
//       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
//       Unable to convert '16/02/2008 12:15:12'.
//       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
//       '2/16/2008' converted to 2/16/2008 12:00:00 AM.
Imports System.Globalization

Class DateTimeParser
   Public Shared Sub Main()
      ' Assume the current culture is en-US. 
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.

      ' Use standard en-US date and time value
      Dim dateValue As Date
      Dim dateString As String = "2/16/2008 12:15:12 PM"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
            
      ' Reverse month and day to conform to the fr-FR culture.
      ' The date is February 16, 2008, 12 hours, 15 minutes and 12 seconds.
      dateString = "16/02/2008 12:15:12"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try

      ' Call another overload of Parse to successfully convert string
      ' formatted according to conventions of fr-FR culture.      
      Try
         dateValue = Date.Parse(dateString, New CultureInfo("fr-FR", False))
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
      
      ' Parse string with date but no time component.
      dateString = "2/16/2008"
      Try
         dateValue = Date.Parse(dateString)
         Console.WriteLine("'{0}' converted to {1}.", dateString, dateValue)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", dateString)
      End Try
   End Sub 
End Class 
' The example displays the following output to the console:
'       '2/16/2008 12:15:12 PM' converted to 2/16/2008 12:15:12 PM.
'       Unable to convert '16/02/2008 12:15:12'.
'       '16/02/2008 12:15:12' converted to 2/16/2008 12:15:12 PM.
'       '2/16/2008' converted to 2/16/2008 12:00:00 AM.

Comentários

Se s contiver informações de fuso horário, esse método retornará um DateTime valor cuja Kind propriedade é DateTimeKind.Local e converterá a data e a hora em em s hora local. Caso contrário, ele não executa nenhuma conversão de fuso horário e retorna um DateTime valor cuja Kind propriedade é DateTimeKind.Unspecified.

Essa sobrecarga tenta analisar s usando as convenções de formatação da cultura atual. A cultura atual é indicada pela CurrentCulture propriedade . Para analisar uma cadeia de caracteres usando as convenções de formatação de uma cultura específica, chame o Parse(String, IFormatProvider) ou as Parse(String, IFormatProvider, DateTimeStyles) sobrecargas.

Essa sobrecarga tenta analisar s usando DateTimeStyles.AllowWhiteSpaces o estilo .

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analisa um intervalo de caracteres em um valor.

public:
 static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<DateTime>::Parse;
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As DateTime

Parâmetros

s
ReadOnlySpan<Char>

O intervalo de caracteres a serem analisados.

provider
IFormatProvider

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

Retornos

O resultado da análise de s.

Implementações

Aplica-se a

Parse(String, IFormatProvider)

Converte a representação da cadeia de caracteres de uma data e hora em seu equivalente DateTime usando as informações de formato específicas da cultura.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<DateTime>::Parse;
public static DateTime Parse (string s, IFormatProvider provider);
public static DateTime Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider) As DateTime

Parâmetros

s
String

Uma cadeia de caracteres que contém uma data e hora a ser convertida. Confira a cadeia de caracteres a ser analisada para obter mais informações.

provider
IFormatProvider

Um objeto que fornece informações de formato específicas de cultura sobre s. Confira Convenções culturais e análise

Retornos

Um objeto equivalente à data e à hora contidas no s, conforme especificado por provider.

Implementações

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.

Exemplos

O exemplo a seguir analisa uma matriz de cadeias de caracteres de data usando as convenções das culturas en-US, fr-FR e de-DE. Ele demonstra que as representações de cadeia de caracteres de uma única data podem ser interpretadas de forma diferente entre diferentes culturas.

using System;
using System.Globalization;

public class ParseDate
{
   public static void Main()
   {
      // Define cultures to be used to parse dates.
      CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                                CultureInfo.CreateSpecificCulture("fr-FR"),
                                CultureInfo.CreateSpecificCulture("de-DE")};
      // Define string representations of a date to be parsed.
      string[] dateStrings = {"01/10/2009 7:34 PM",
                              "10.01.2009 19:34",
                              "10-1-2009 19:34" };
      // Parse dates using each culture.
      foreach (CultureInfo culture in cultures)
      {
         DateTime dateValue;
         Console.WriteLine("Attempted conversions using {0} culture.",
                           culture.Name);
         foreach (string dateString in dateStrings)
         {
            try {
               dateValue = DateTime.Parse(dateString, culture);
               Console.WriteLine("   Converted '{0}' to {1}.",
                                 dateString, dateValue.ToString("f", culture));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.",
                                 dateString, culture.Name);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
open System
open System.Globalization

// Define cultures to be used to parse dates.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "de-DE" ]

// Define string representations of a date to be parsed.
let dateStrings = 
    [ "01/10/2009 7:34 PM"
      "10.01.2009 19:34"
      "10-1-2009 19:34" ]

// Parse dates using each culture.
for culture in cultures do
    printfn $"Attempted conversions using {culture.Name} culture."
    for dateString in dateStrings do
        try
            let dateValue = DateTime.Parse(dateString, culture)
            printfn $"""   Converted '{dateString}' to {dateValue.ToString("f", culture)}."""
        with :? FormatException ->
            printfn $"   Unable to convert '{dateString}' for culture {culture.Name}." 
    printfn ""


// The example displays the following output to the console:
//       Attempted conversions using en-US culture.
//          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
//          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
//
//       Attempted conversions using fr-FR culture.
//          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
//          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
//          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
//
//       Attempted conversions using de-DE culture.
//          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
//          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
//          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.
Imports System.Globalization

Module ParseDate
   Public Sub Main()
      ' Define cultures to be used to parse dates.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("de-DE")}
      ' Define string representations of a date to be parsed.
      Dim dateStrings() As String = {"01/10/2009 7:34 PM", _
                                     "10.01.2009 19:34", _
                                     "10-1-2009 19:34" }
      ' Parse dates using each culture.
      For Each culture In cultures
         Dim dateValue As Date
         Console.WriteLine("Attempted conversions using {0} culture.", culture.Name)
         For Each dateString As String In dateStrings
            Try
               dateValue = Date.Parse(dateString, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 dateString, dateValue.ToString("f", culture))
            Catch e As FormatException
               Console.WriteLine("   Unable to convert '{0}' for culture {1}.", _
                                 dateString, culture.Name)
            End Try                                                
         Next
         Console.WriteLine()
      Next                                                                                     
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversions using en-US culture.
'          Converted '01/10/2009 7:34 PM' to Saturday, January 10, 2009 7:34 PM.
'          Converted '10.01.2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'          Converted '10-1-2009 19:34' to Thursday, October 01, 2009 7:34 PM.
'       
'       Attempted conversions using fr-FR culture.
'          Converted '01/10/2009 7:34 PM' to jeudi 1 octobre 2009 19:34.
'          Converted '10.01.2009 19:34' to samedi 10 janvier 2009 19:34.
'          Converted '10-1-2009 19:34' to samedi 10 janvier 2009 19:34.
'       
'       Attempted conversions using de-DE culture.
'          Converted '01/10/2009 7:34 PM' to Donnerstag, 1. Oktober 2009 19:34.
'          Converted '10.01.2009 19:34' to Samstag, 10. Januar 2009 19:34.
'          Converted '10-1-2009 19:34' to Samstag, 10. Januar 2009 19:34.

Comentários

Se s contiver informações de fuso horário, esse método retornará um DateTime valor cuja Kind propriedade é DateTimeKind.Local e converterá a data e a hora em em s hora local. Caso contrário, ele não executa nenhuma conversão de fuso horário e retorna um DateTime valor cuja Kind propriedade é DateTimeKind.Unspecified.

Essa sobrecarga tenta analisar s usando o DateTimeStyles.AllowWhiteSpaces estilo .

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Converte um intervalo de memória que contém uma representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as informações de formato e um estilo de formatação específicos da cultura.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider? provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = default, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None);
static member Parse : ReadOnlySpan<char> * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional provider As IFormatProvider = Nothing, Optional styles As DateTimeStyles = System.Globalization.DateTimeStyles.None) As DateTime

Parâmetros

s
ReadOnlySpan<Char>

O intervalo de memória que contém a cadeia de caracteres a ser analisada. Confira a cadeia de caracteres a ser analisada para obter mais informações.

provider
IFormatProvider

Um objeto que fornece informações de formato específicas de cultura sobre s. Confira Convenções culturais e análise

styles
DateTimeStyles

Uma combinação bit a bit dos valores de enumeração que indica os elementos de estilo que podem estar presentes em s para que a operação de análise seja bem-sucedida e que define como interpretar a data analisada em relação ao fuso horário atual ou à data atual. Um valor típico a ser especificado é None.

Retornos

Um objeto equivalente à data e hora contida no s, conforme especificado por provider e styles.

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.

styles contém uma combinação inválida de valores DateTimeStyles. Por exemplo, AssumeLocal e AssumeUniversal.

Aplica-se a

Parse(String, IFormatProvider, DateTimeStyles)

Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as informações de formato e um estilo de formatação específicos da cultura.

public:
 static DateTime Parse(System::String ^ s, IFormatProvider ^ provider, System::Globalization::DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider provider, System.Globalization.DateTimeStyles styles);
public static DateTime Parse (string s, IFormatProvider? provider, System.Globalization.DateTimeStyles styles);
static member Parse : string * IFormatProvider * System.Globalization.DateTimeStyles -> DateTime
Public Shared Function Parse (s As String, provider As IFormatProvider, styles As DateTimeStyles) As DateTime

Parâmetros

s
String

Uma cadeia de caracteres que contém uma data e hora a ser convertida. Confira a cadeia de caracteres a ser analisada para obter mais informações.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s. Confira Convenções culturais e análise

styles
DateTimeStyles

Uma combinação bit a bit dos valores de enumeração que indica os elementos de estilo que podem estar presentes em s para que a operação de análise seja bem-sucedida e que define como interpretar a data analisada em relação ao fuso horário atual ou à data atual. Um valor típico a ser especificado é None.

Retornos

Um objeto equivalente à data e hora contida no s, conforme especificado por provider e styles.

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.

styles contém uma combinação inválida de valores DateTimeStyles. Por exemplo, AssumeLocal e AssumeUniversal.

Exemplos

O exemplo a seguir demonstra o Parse(String, IFormatProvider, DateTimeStyles) método e exibe o valor da Kind propriedade dos valores resultantes DateTime .

using System;
using System.Globalization;

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

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

      // Parse the same date and time with the AssumeLocal style.
      styles = DateTimeStyles.AssumeLocal;
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

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

      // Attempt to convert a string in improper ISO 8601 format.
      dateString = "03/01/2009T10:00:00-5:00";
      try {
         result = DateTime.Parse(dateString, culture, styles);
         Console.WriteLine("{0} converted to {1} {2}.",
                           dateString, result, result.Kind.ToString());
      }
      catch (FormatException) {
         Console.WriteLine("Unable to convert {0} to a date and time.", dateString);
      }

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

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

    // Parse the same date and time with the AssumeLocal style.
    let styles = DateTimeStyles.AssumeLocal
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

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

    // Attempt to convert a string in improper ISO 8601 format.
    let dateString = "03/01/2009T10:00:00-5:00"
    try
        let result = DateTime.Parse(dateString, culture, styles)
        printfn $"{dateString} converted to {result} {result.Kind}."
    with :? FormatException ->
        printfn $"Unable to convert {dateString} to a date and time."

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

    0

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

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

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

Comentários

Essa sobrecarga de método converte a data e a hora em s e define a Kind propriedade do valor retornado DateTime da seguinte maneira:

If Conversão de fuso horário Propriedade de tipo
s não contém nenhuma informação de fuso horário. Nenhum. DateTimeKind.Unspecified
s contém informações de fuso horário. Para a hora no fuso horário local DateTimeKind.Local
s contém informações de fuso horário e styles inclui o DateTimeStyles.AdjustToUniversal sinalizador . Para UTC (Tempo Universal Coordenado) DateTimeKind.Utc
s contém o designador de fuso horário Z ou GMT e styles inclui o DateTimeStyles.RoundtripKind. Nenhum. DateTimeKind.Utc

Confira também

Aplica-se a