DateTime.Parse Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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

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 de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando informações de formato específicas da cultura.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Converte um intervalo de memória que contém a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando informações de formato específicas da cultura e um estilo de formatação.
Parse(String, IFormatProvider, DateTimeStyles)	Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando informações de formato específicas da cultura e um estilo de formatação.

Exemplos

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

Nota

Alguns exemplos de C# neste artigo são executados no Try.NET executor de código embutido e playground. Selecione Executar para executar um exemplo em uma janela interativa. Depois de executar o código, você pode modificá-lo e executar o código modificado selecionando Executar novamente. O código modificado é executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todas as mensagens de erro do compilador C#.

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

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

Comentários

Nesta seção:

Qual método eu chamo?
a cadeia de caracteres a ser analisada
de análise e convenções culturais
elementos de análise e estilo
o valor retornado e o DateTime.Kind

Qual método eu chamo?

Para	Chamar
Analise uma cadeia de caracteres de data e hora usando as convenções da cultura atual.	sobrecarga 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 de 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 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 Parse(String, IFormatProvider, DateTimeStyles)
Analise uma cadeia de caracteres de data e hora sem tratar 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 método ToString(String) e chame a sobrecarga de Parse(String, IFormatProvider, DateTimeStyles) com DateTimeStyles.RoundtripKind
Analise uma cadeia de caracteres de data e hora em um formato fixo entre limites de máquina (e possivelmente culturais).	método DateTime.ParseExact ou DateTime.TryParseExact

A cadeia de caracteres a ser analisada

O método Parse 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 exceção FormatException.

Importante

Se a operação de análise falhar devido a um formato de cadeia de caracteres não reconhecido, o método Parse gerará um FormatException, enquanto o método TryParse retornará false. Como o tratamento de exceções pode ser caro, você deve usar Parse quando a operação de análise deve ter êxito porque a fonte de entrada é confiável. TryParse é preferível quando as 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 cadeias de caracteres que não analisam 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 uma data, mas sem componente de hora. Se o componente de hora estiver ausente, o método pressupõe meia-noite 12:00. Se o componente de data tiver um ano de dois dígitos, ele será convertido em um ano com base no Calendar.TwoDigitYearMax do calendário atual da cultura atual ou no calendário atual da cultura especificada (se você usar uma sobrecarga com um argumento de provider não nulo).
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 sobrecarga Parse(String, IFormatProvider, DateTimeStyles) e inclua DateTimeStyles.NoCurrentDateDefault no argumento styles, nesse caso, 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 sobrecarga de Parse(String, IFormatProvider, DateTimeStyles) e incluir DateTimeStyles.NoCurrentDateDefault no argumento styles, nesse caso, o método assume 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 o 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 de 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 a análise e as convenções culturais), o método Parse 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 método Parse 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 método DateTime.ParseExact e forneça um especificador de formato.

Convenções culturais e de análise

Todas as sobrecargas do método Parse diferenciam a cultura, a menos que a cadeia de caracteres a ser analisada (que é 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 objeto DateTimeFormatInfo derivado da seguinte maneira:

Importante

Eras nos calendários japoneses são baseadas no reinado do imperador e, portanto, espera-se que mudem. Por exemplo, 1º de maio de 2019 marcou o início da era Reiwa no JapaneseCalendar e JapaneseLunisolarCalendar. Essa mudança de era afeta todos os aplicativos que usam esses calendários. Para obter mais informações e determinar se seus aplicativos são afetados, consulte Tratando 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 obter recursos no .NET que dão suporte a calendários com várias eras e práticas recomendadas ao trabalhar com calendários que dão suporte a várias eras, consulte Trabalhando com eras.

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

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

Se você analisar uma cadeia de caracteres de data e hora usando um objeto DateTimeFormatInfo com configurações personalizadas diferentes das de uma cultura padrão, use o método ParseExact em vez do método Parse 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 método Parse tenta analisar uma cadeia de caracteres com vários padrões de análise implícitos, todos os quais podem falhar. Por outro lado, o método ParseExact exige que você designe explicitamente um ou mais padrões exatos de análise que provavelmente serão bem-sucedidos. Para obter mais informações, consulte a seção "DateTimeFormatInfo and Dynamic Data" no tópico DateTimeFormatInfo.

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 objeto IFormatProvider que representa uma cultura diferente da cultura invariável podem falhar inesperadamente se ocorrer qualquer um dos seguintes procedimentos:

Os dados específicos da cultura foram alterados entre 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 método ParseExact 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 valor DateTime em um formato binário.

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

Elementos de análise e estilo

Todas as sobrecargas de Parse 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 agrupadas com um par de caracteres NÚM SIGN à esquerda e à direita ("#", U+0023) e podem ser trilhados com um ou mais caracteres NULL (U+0000).

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

Membro DateTimeStyles	Efeito na conversão
AdjustToUniversal	Analisa `s` 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 informações de fuso horário, mas `styles` incluir o sinalizador AssumeLocal, o método analisará a cadeia de caracteres, chamará ToUniversalTime para converter o valor de DateTime retornado em UTC e definirá a propriedade Kind 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 sinalizador AssumeUniversal, o método analisará a cadeia de caracteres, não executará nenhuma conversão de fuso horário no valor de DateTime retornado e definirá a propriedade Kind como DateTimeKind.Utc. - Em todos os outros casos, o sinalizador não tem efeito.
AllowInnerWhite	Esse valor é ignorado. O espaço em branco interno é sempre permitido nos elementos de data e hora de `s`.
AllowLeadingWhite	Esse valor é ignorado. O espaço em branco à esquerda é sempre permitido nos elementos de data e hora de `s`.
AllowTrailingWhite	Esse 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 DateTimeStyles mais restritivo, como None.
AssumeLocal	Especifica que, se `s` não tiver informações de fuso horário, a hora local será assumida. A menos que o sinalizador AdjustToUniversal esteja presente, a propriedade Kind do valor de DateTime retornado será definida como DateTimeKind.Local.
AssumeUniversal	Especifica que, se `s` não tiver informações de fuso horário, o UTC será assumido. A menos que o sinalizador AdjustToUniversal esteja presente, o método converterá o valor de DateTime retornado de UTC para hora local e definirá sua propriedade Kind como DateTimeKind.Local.
None	Embora seja 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 valor DateTime que representa uma hora local com sua propriedade Kind definida como DateTimeKind.Local. Normalmente, essa cadeia de caracteres é criada chamando o método DateTime.ToString(String) e usando o especificador de formato padrão "o", "r" ou "u".

O valor retornado e DateTime.Kind

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

Tempo Universal Coordenado (System.DateTimeKind.Utc).
A hora no fuso horário local (System.DateTimeKind.Local).
A hora em um fuso horário desconhecido (System.DateTimeKind.Unspecified).

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

Se	Conversão de fuso horário	Propriedade Kind
`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 sinalizador de AdjustToUniversal.	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 sinalizador RoundtripKind.	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 Kind de data e hora durante uma operação de formatação e análise usando o sinalizador DateTimeStyles.RoundtripKind. O exemplo a seguir ilustra como o sinalizador RoundtripKind afeta a operação de análise em valores DateTime convertidos em 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)

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

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 serem convertidas. Consulte A cadeia de caracteres para analisar para obter mais informações.

Retornos

DateTime

Um objeto equivalente à data e hora contidas em s.

Exceções

ArgumentNullException

s é null.

FormatException

s não contém uma representação de 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 por:

Usando o provedor de formato padrão, que fornece as convenções de formatação da cultura atual do computador usada 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 exceção de FormatException que é gerada quando o método tenta analisar a representação de cadeia de caracteres de uma data e hora usando algumas convenções de formatação de outras culturas. 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 valor DateTime cuja propriedade Kind é DateTimeKind.Local e converterá a data e a hora em s em hora local. Caso contrário, ele não executa nenhuma conversão de fuso horário e retorna um valor de DateTime cuja propriedade Kind é DateTimeKind.Unspecified.

Essa sobrecarga tenta analisar s usando as convenções de formatação da cultura atual. A cultura atual é indicada pela propriedade CurrentCulture. 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 sobrecargas de Parse(String, IFormatProvider, DateTimeStyles).

Essa sobrecarga tenta analisar s usando DateTimeStyles.AllowWhiteSpaces estilo.

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

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 da cultura sobre s.

Retornos

DateTime

O resultado da análise de s.

Implementações

Parse(ReadOnlySpan<Char>, IFormatProvider)

Aplica-se a

Parse(String, IFormatProvider)

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando 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 serem convertidas. Consulte A cadeia de caracteres para analisar para obter mais informações.

provider: IFormatProvider

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

Retornos

DateTime

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

Implementações

Parse(String, IFormatProvider)

Exceções

ArgumentNullException

s é null.

FormatException

s não contém uma representação de 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-FRe 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

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

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

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

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. Consulte A cadeia de caracteres para analisar para obter mais informações.

provider: IFormatProvider

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

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

DateTime

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

Exceções

FormatException

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

ArgumentException

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

Aplica-se a

Parse(String, IFormatProvider, DateTimeStyles)

Origem:: DateTime.cs

Origem:: DateTime.cs

Origem:: DateTime.cs

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

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 serem convertidas. Consulte A cadeia de caracteres para analisar para obter mais informações.

provider: IFormatProvider

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

styles: DateTimeStyles

Retornos

DateTime

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

Exceções

ArgumentNullException

s é null.

FormatException

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

ArgumentException

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

Exemplos

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

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 propriedade Kind do valor DateTime retornado da seguinte maneira:

Se	Conversão de fuso horário	Propriedade Kind
`s` não contém informações 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 sinalizador de DateTimeStyles.AdjustToUniversal.	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

Partilhar via

DateTime.Parse Método

Definição

Sobrecargas

Exemplos

Comentários

Qual método eu chamo?

A cadeia de caracteres a ser analisada

Convenções culturais e de análise

Elementos de análise e estilo

O valor retornado e DateTime.Kind

Parse(String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parâmetros

Retornos

Implementações

Aplica-se a

Parse(String, IFormatProvider)

Parâmetros

Retornos

Implementações

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

Parâmetros

Retornos

Exceções

Aplica-se a

Parse(String, IFormatProvider, DateTimeStyles)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Comentários

Recursos adicionais