DateTime.Parse DateTime.Parse DateTime.Parse DateTime.Parse Method

Definição

Converte a representação da cadeia de caracteres de uma data e hora ao seu equivalente DateTime.Converts the string representation of a date and time to its DateTime equivalent.

Sobrecargas

Parse(String) Parse(String) Parse(String) 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 do thread atual.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

Exemplos

Vários exemplos que chamam o DateTime.Parse método são intercalados durante a seção de comentários deste artigo e na documentação para as sobrecargas individuais DateTime.Parse .Numerous examples that call the DateTime.Parse method are interspersed throughout the Remarks section of this article and in the documentation for the individual DateTime.Parse overloads.

Observação

Alguns exemplos de C# neste artigo são executados no playground e no executador de código embutido Try.NET.Some C# examples in this article run in the Try.NET inline code runner and playground. Clique no botão Executar para executar um exemplo em uma janela interativa.Select the Run button to run an example in an interactive window. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

O fuso horário local do executador de código embutido Try.NET e do playground é o Tempo Universal Coordenado ou UTC.The local time zone of the Try.NET inline code runner and playground is Coordinated Universal Time, or UTC. Isso pode afetar o comportamento e a saída dos exemplos que ilustram os tipos DateTime, DateTimeOffset e TimeZoneInfo e seus membros.This may affect the behavior and the output of examples that illustrate the DateTime, DateTimeOffset, and TimeZoneInfo types and their members.

Você também pode baixar um conjunto completo de DateTime.Parse exemplos, que estão incluídos em um projeto do .NET Core 2,0 C# para o e um projeto .NET Core 2,0 para Visual Basic, no repositório dotnet/exemplos do GitHub.You can also download a complete set of DateTime.Parse examples, which are included in a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Comentários

Nesta seção:In this section:

Qual método devo chamar?Which method do I call?

ParaTo CallCall
Analise uma cadeia de caracteres de data e hora usando as convenções da cultura atual.Parse a date and time string by using the conventions of the current culture. sobrecarga de Parse(String)Parse(String) overload
Analise uma cadeia de caracteres de data e hora usando as convenções de uma cultura específica.Parse a date and time string by using the conventions of a specific culture. Parse(String, IFormatProvider)sobrecarga (Confira análise e convenções culturais)Parse(String, IFormatProvider) overload (see Parsing and Cultural Conventions)
Analise uma cadeia de caracteres de data e hora com elementos de estilo especiais (como um espaço em branco ou nenhum espaço em branco).Parse a date and time string with special style elements (such as white space or no white space). sobrecarga de Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Analise uma cadeia de caracteres de data e hora que deve estar em um formato específico.Parse a date and time string that must be in a particular format. DateTime.ParseExact ou DateTime.TryParseExactDateTime.ParseExact or DateTime.TryParseExact
Analise uma cadeia de caracteres de data e hora e execute uma conversão para UTC ou hora local.Parse a date and time string and perform a conversion to UTC or local time. sobrecarga de Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider, DateTimeStyles) overload
Analisar uma cadeia de caracteres de data e hora sem tratamento de exceções.Parse a date and time string without handling exceptions. Método DateTime.TryParseDateTime.TryParse method
Restauração (ida e volta) um valor de data e hora criado por uma operação de formatação.Restore (round-trip) a date and time value created by a formatting operation. Passe a cadeia de caracteres de formato padrão "o" ou "r ToString(String) " para o método e Parse(String, IFormatProvider, DateTimeStyles) chame a sobrecarga comDateTimeStyles.RoundtripKindPass the "o" or "r" standard format string to the ToString(String) method, and call the Parse(String, IFormatProvider, DateTimeStyles) overload with DateTimeStyles.RoundtripKind
Analise uma cadeia de caracteres de data e hora em um formato fixo entre limites de máquina (e possivelmente cultural).Parse a date and time string in a fixed format across machine (and possibly cultural) boundaries. DateTime.ParseExactmétodo DateTime.TryParseExact orDateTime.ParseExact or DateTime.TryParseExact method

A cadeia de caracteres a ser analisadaThe string to parse

O Parse método tenta converter a representação de cadeia de caracteres de um valor de data e DateTime hora em seu equivalente.The Parse method tries to convert the string representation of a date and time value to its DateTime equivalent. Ele tenta analisar a cadeia de caracteres de entrada completamente sem FormatException lançar uma exceção.It tries to parse the input string completely without throwing a FormatException exception.

Importante

Se a operação de análise falhar devido a um formato de cadeia de caracteres não reconhecido Parse , o método FormatExceptionlançará um TryParse , enquanto falseo método retornará.If the parsing operation fails because of an unrecognized string format, the Parse method throws a FormatException, whereas the TryParse method returns false. Como o tratamento de exceções pode ser caro, você Parse deve usar quando a operação de análise é esperada com sucesso porque a fonte de entrada é confiável.Because exception handling can be expensive, you should use Parse when the parsing operation is expected to succeed because the input source is trusted. 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 as cadeias de caracteres que não são analisadas com êxito.TryParse is preferable when parsing failures are likely, particularly because an input source is not trusted, or you have reasonable default values to substitute for strings that do not parse successfully.

A cadeia de caracteres a ser analisada pode usar qualquer uma das seguintes formas:The string to be parsed can take any of the following forms:

  • Uma cadeia de caracteres com um componente Date e time.A string with a date and a time component.

  • Uma cadeia de caracteres com um componente Date, mas não time.A string with a date but no time component. Se o componente de tempo estiver ausente, o método assumirá 12:00 de meia-noite.If the time component is absent, the method assumes 12:00 midnight. Se o componente de data tiver um ano de dois dígitos, ele será convertido em um ano com base Calendar.TwoDigitYearMax no 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 ).If the date component has a two-digit year, it is converted to a year based on the Calendar.TwoDigitYearMax of the current culture's current calendar or the specified culture's current calendar (if you use an overload with a non-null provider argument).

  • Uma cadeia de caracteres com um componente de data que inclui somente o mês e o ano, mas não o componente de dia.A string with a date component that includes only the month and the year but no day component. O método assume o primeiro dia do mês.The method assumes the first day of the month.

  • Uma cadeia de caracteres com um componente de data que inclui somente o mês e o dia, mas nenhum componente de ano.A string with a date component that includes only the month and the day but no year component. O método assume o ano atual.The method assumes the current year.

  • Uma cadeia de caracteres com um componente de hora mas sem data.A string with a time but no date component. O método assume a data atual, a menos que Parse(String, IFormatProvider, DateTimeStyles) você chame a DateTimeStyles.NoCurrentDateDefault sobrecarga e styles inclua no argumento; nesse caso, o método assume uma data de 1º de janeiro de 0001.The method assumes the current date unless you call the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Uma cadeia de caracteres com um componente de hora que inclui apenas a hora e um designador AM/PM, sem componente de data.A string with a time component that includes only the hour and an AM/PM designator, with no date component. O método assume a data atual e uma hora sem minutos e nenhum segundos.The method assumes the current date and a time with no minutes and no seconds. Você pode alterar esse comportamento chamando a Parse(String, IFormatProvider, DateTimeStyles) sobrecarga e incluir DateTimeStyles.NoCurrentDateDefault no styles argumento; nesse caso, o método assume uma data de 1º de janeiro de 0001.You can change this behavior by calling the Parse(String, IFormatProvider, DateTimeStyles) overload and include DateTimeStyles.NoCurrentDateDefault in the styles argument, in which case the method assumes a date of January 1, 0001.

  • Uma cadeia de caracteres que inclui informações de fuso horário e está em conformidade com o ISO 8601.A string that includes time zone information and conforms to ISO 8601. Nos exemplos a seguir, a primeira cadeia de caracteres designa a hora universal coordenada (UTC) e a segunda designa a hora em um fuso horário que é de sete horas antes de UTC:In the following examples, the first string designates Coordinated Universal Time (UTC), and the second designates the time in a time zone that's seven hours earlier than UTC:

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

  • Uma cadeia de caracteres que inclui o designador GMT e está em conformidade com o formato de tempo RFC 1123; por exemplo:A string that includes the GMT designator and conforms to the RFC 1123 time format; for example:

    "SAT, 01 Nov 2008 19:35:00 GMT""Sat, 01 Nov 2008 19:35:00 GMT"

  • Uma cadeia de caracteres que inclui a data e a hora junto com as informações de deslocamento de fuso horário; por exemplo:A string that includes the date and time along with time zone offset information; for example:

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

O exemplo a seguir analisa as 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:The following example parses strings in each of these formats by using the formatting conventions of the current culture, which in this case is the en-US culture:

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


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 representa um dia bissexto em um ano bissexto no calendário usado pelo método de análise (consulte análise e convenções culturais), o Parse método analisa a cadeia de caracteres com êxito.If the input string represents a leap day in a leap year in the calendar used by the parsing method (see Parsing and cultural conventions), the Parse method parses the string successfully. Se a cadeia de caracteres de entrada representa um dia bissexto em um ano não bissexto, o método FormatExceptionlançará um.If the input string represents a leap day in a non-leap year, the method throws a FormatException.

Como o Parse método tenta analisar a representação da cadeia de caracteres de uma data e hora usando as regras de formatação da cultura atual ou especificada, tentar analisar uma cadeia de caracteres entre diferentes culturas pode falhar.Because the Parse method tries to parse the string representation of a date and time by using the formatting rules of the current or a specified culture, trying to parse a string across different cultures can fail. 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.To parse a specific date and time format across different locales, use one of the overloads of the DateTime.ParseExact method and provide a format specifier.

Convenções de análise e culturaisParsing and cultural conventions

Todas as sobrecargas do Parse método são sensíveis à cultura, a menos que a cadeia de caracteres a ser analisada s (que é representada pela na tabela a seguir) esteja de acordo com o padrão ISO 8601.All overloads of the Parse method are culture-sensitive unless the string to be parsed (which is represented by s in the following table) conforms to the ISO 8601 pattern. A operação de análise usa as informações de formatação em DateTimeFormatInfo um objeto que é derivado da seguinte maneira:The parsing operation uses the formatting information in a DateTimeFormatInfo object that is derived as follows:

Importante

As eras nos calendários japoneses se baseiam no reinado do Imperador e, portanto, estão sujeitas a alterações.Eras in the Japanese calendars are based on the emperor's reign and are therefore expected to change. Por exemplo, 1º de maio de 2019 marcou o início da era Reiwa no JapaneseCalendar e no JapaneseLunisolarCalendar.For example, May 1, 2019 marked the beginning of the Reiwa era in the JapaneseCalendar and JapaneseLunisolarCalendar. Tal alteração de eras afeta todos os aplicativos que usam esses calendários.Such a change of era affects all applications that use these calendars. Veja Tratamento de uma nova era no calendário japonês no .NET para obter mais informações e para determinar se seus aplicativos são afetados.See Handling a new era in the Japanese calendar in .NET for more information and to determine whether your applications are affected. Veja Preparar seu aplicativo para a mudança de era no calendário japonês para obter informações sobre como testar seus aplicativos em sistemas Windows para assegurar que eles estejam preparados para a alteração de era.See Prepare your application for the Japanese era change for information on testing your applications on Windows systems to ensure their readiness for the era change. Confira Trabalhando com eras para ver recursos do .NET que dão suporte a calendários com várias eras e confira práticas recomendadas de trabalho com calendários que dão suporte a várias eras.See Working with eras for features in .NET that support calendars with multiple eras and for best practices when working with calendars that support multiple eras.

Se você chamarIf you call E provider éAnd provider is As informações de formatação são derivadas deFormatting information is derived from
Parse(String) - A cultura do thread atual (propriedade DateTimeFormatInfo.CurrentInfo )The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) um DateTimeFormatInfo objetoa DateTimeFormatInfo object O objeto DateTimeFormatInfo especificadoThe specified DateTimeFormatInfo object
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) null A cultura do thread atual (propriedade DateTimeFormatInfo.CurrentInfo )The current thread culture (DateTimeFormatInfo.CurrentInfo property)
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) um CultureInfo objetoa CultureInfo object A propriedade CultureInfo.DateTimeFormatThe CultureInfo.DateTimeFormat property
Parse(String, IFormatProvider) ou Parse(String, IFormatProvider, DateTimeStyles)Parse(String, IFormatProvider) or Parse(String, IFormatProvider, DateTimeStyles) Implementação IFormatProvider personalizadaCustom IFormatProvider implementation O método IFormatProvider.GetFormatThe IFormatProvider.GetFormat method

Quando as informações de formatação são derivadas DateTimeFormatInfo de um objeto DateTimeFormatInfo.Calendar , a propriedade define o calendário usado na operação de análise.When formatting information is derived from a DateTimeFormatInfo object, the DateTimeFormatInfo.Calendar property defines the calendar used in the parsing operation.

Se você analisar uma cadeia de caracteres de data e hora DateTimeFormatInfo usando um objeto com configurações personalizadas diferentes das 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.If you parse a date and time string by using a DateTimeFormatInfo object with customized settings that are different from those of a standard culture, use the ParseExact method instead of the Parse method to improve the chances for a successful conversion. Uma cadeia de caracteres de data e hora não padrão pode ser complicada e difícil de analisar.A non-standard date and time string can be complicated and difficult to parse. O Parse método tenta analisar uma cadeia de caracteres com vários padrões de análise implícitos, que podem falhar.The Parse method tries to parse a string with several implicit parse patterns, all of which might fail. Por outro lado, ParseExact o método exige design explícito de um ou mais padrões de análise exatos que provavelmente serão bem-sucedidos.In contrast, the ParseExact method requires you to explicitly designate one or more exact parse patterns that are likely to succeed. Para obter mais informações, consulte a seção "DateTimeFormatInfo e dados dinâmicos" no DateTimeFormatInfo tópico.For more information, see the "DateTimeFormatInfo and Dynamic Data" section in the DateTimeFormatInfo topic.

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.Note that the formatting conventions for a particular culture are dynamic and can be subject to change. 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 IFormatProvider um objeto que representa uma cultura diferente da cultura invariável podem falhar inesperadamente se qualquer uma das seguintes situações ocorrer:This means that parsing operations that depend on the formatting conventions of the default (current) culture or that specify an IFormatProvider object that represents a culture other than the invariant culture can unexpectedly fail if any of the following occurs:

  • Os dados específicos da cultura foram alterados entre as versões principal ou secundária do .NET Framework ou como resultado de uma atualização para a versão existente do .NET Framework.The culture-specific data has changed between major or minor versions of the .NET Framework or as the result of an update to the existing version of the .NET Framework.
  • Os dados específicos da cultura refletem as preferências do usuário, que podem variar de máquina para máquina ou sessão para sessão.The culture-specific data reflects user preferences, which can vary from machine to machine or session to session.
  • Os dados específicos da cultura representam uma cultura substituta que substitui as configurações de uma cultura padrão ou uma cultura personalizada.The culture-specific data represents a replacement culture that overrides the settings of a standard culture or a custom culture.

Para evitar as dificuldades de analisar os dados e as cadeias de caracteres de tempo associados às alterações nos dados culturais, você pode analisar as cadeias de caracteres de data e hora usando a cultura ParseExact invariável ou pode chamar o método ou TryParseExact e especificar o formato exato da cadeia de caracteres a ser analisada.To prevent the difficulties in parsing data and time strings that are associated with changes in cultural data, you can parse date and time strings by using the invariant culture, or you can call the ParseExact or TryParseExact method and specify the exact format of the string to be parsed. Se você estiver serializando e desserializando dados de data e hora, poderá usar as convenções de formatação da cultura invariável ou pode serializar e desserializar o DateTime valor em um formato binário.If you are serializing and deserializing date and time data, you can either use the formatting conventions of the invariant culture, or you can serialize and deserialize the DateTime value in a binary format.

Para obter mais informações, consulte a seção "dados de cultura dinâmica CultureInfo " no tópico e a seção "persistindo valores DateTime de DateTime" no tópico.For more information see the "Dynamic culture data" section in the CultureInfo topic and the "Persisting DateTime values" section in the DateTime topic.

Elementos de análise e estiloParsing and style elements

Todas Parse as sobrecargas ignoram caracteres de espaço em branco à esquerda, interna ou à direita na cadeia de caracteres de entrada s (que é representada por na tabela a seguir).All Parse overloads ignore leading, inner, or trailing white-space characters in the input string (which is represented by s in the following table). A data e a hora podem ficar entredas com um par de caracteres de sinal de número à esquerda e à direita ("#", U + 0023) e podem ser enbarradas com um ou mais caracteres nulos (U + 0000).The date and time can be bracketed with a pair of leading and trailing NUMBER SIGN characters ("#", U+0023), and can be trailed with one or more NULL characters (U+0000).

Além disso, a Parse(String, IFormatProvider, DateTimeStyles) sobrecarga tem um styles parâmetro que consiste em um DateTimeStyles ou mais membros da enumeração.In addition, the Parse(String, IFormatProvider, DateTimeStyles) overload has a styles parameter that consists of one or more members of the DateTimeStyles enumeration. Esse parâmetro define como s o deve ser interpretado e como a operação s de análise deve ser convertida em uma data e hora.This parameter defines how s should be interpreted and how the parse operation should convert s to a date and time. A tabela a seguir descreve o efeito de DateTimeStyles cada membro na operação de análise.The following table describes the effect of each DateTimeStyles member on the parse operation.

Membro DateTimeStylesDateTimeStyles member Efeito na conversãoEffect on conversion
AdjustToUniversal s Analisa e, se necessário, converte-o em UTC, da seguinte maneira:Parses s and, if necessary, converts it to UTC, as follows:

-Se s incluir um deslocamento de fuso horário ou se s não contiver informações de fuso styles horário, AssumeLocal mas incluir o sinalizador, o método analisará a ToUniversalTime cadeia de caracteres, DateTime chamadas para converter o valor retornado em UTC e define a Kind Propriedade como. DateTimeKind.Utc- If s includes a time zone offset, or if s contains no time zone information but styles includes the AssumeLocal flag, the method parses the string, calls ToUniversalTime to convert the returned DateTime value to UTC, and sets the Kind property to DateTimeKind.Utc.
-Se s indica que ele representa UTC ou se s não contém informações de fuso horário, mas styles inclui o AssumeUniversal sinalizador, o método analisa a cadeia de caracteres, não executa nenhuma conversão de fuso horário DateTime no retorno valor e define a Kind Propriedade como. DateTimeKind.Utc- If s indicates that it represents UTC, or if s does not contain time zone information but styles includes the AssumeUniversal flag, the method parses the string, performs no time zone conversion on the returned DateTime value, and sets the Kind property to DateTimeKind.Utc.
-Em todos os outros casos, o sinalizador não tem nenhum efeito.- In all other cases, the flag has no effect.
AllowInnerWhite Este valor é ignorado.This value is ignored. O espaço em branco interno sempre é permitido nos elementos Date e time sde.Inner white space is always permitted in the date and time elements of s.
AllowLeadingWhite Este valor é ignorado.This value is ignored. O espaço em branco à esquerda sempre é permitido nos elementos de data se hora de.Leading white space is always permitted in the date and time elements of s.
AllowTrailingWhite Este valor é ignorado.This value is ignored. O espaço em branco à direita sempre é permitido nos elementos de data e shora de.Trailing white space is always permitted in the date and time elements of s.
AllowWhiteSpaces Especifica que s pode conter espaços em branco à esquerda, interna e à direita.Specifies that s may contain leading, inner, and trailing white spaces. Este é o comportamento padrão.This is the default behavior. Ele não pode ser substituído ao fornecer um valor de DateTimeStyles Enumeração mais restritivo None, como.It cannot be overridden by supplying a more restrictive DateTimeStyles enumeration value such as None.
AssumeLocal Especifica se s o não tem nenhuma informação de fuso horário, a hora local é assumida.Specifies that if s lacks any time zone information, local time is assumed. A menos que o sinalizador AdjustToUniversal esteja presente, a propriedade Kind do valor DateTime retornado é definida como DateTimeKind.Local.Unless the AdjustToUniversal flag is present, the Kind property of the returned DateTime value is set to DateTimeKind.Local.
AssumeUniversal Especifica se s o não tem nenhuma informação de fuso horário, o UTC é assumido.Specifies that if s lacks any time zone information, UTC is assumed. 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.Unless the AdjustToUniversal flag is present, the method converts the returned DateTime value from UTC to local time and sets its Kind property to DateTimeKind.Local.
None Embora válido, esse valor é ignorado.Although valid, this value is ignored.
RoundtripKind Para cadeias de caracteres que contêm informações de fuso horário, o tenta impedir a conversão de uma cadeia de DateTime caracteres de data e hora em um valor Kind que representa uma DateTimeKind.Localhora local com sua propriedade definida como.For strings that contain time zone information, tries to prevent the conversion of a date and time string to a DateTime value that represents a local time with its Kind property set to DateTimeKind.Local. 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".Typically, such a string is created by calling the DateTime.ToString(String) method and by using the "o", "r", or "u" standard format specifier.

O valor de retorno e DateTime. KindThe return value and DateTime.Kind

As DateTime.Parse sobrecargas retornam DateTime um valor Kind cuja propriedade inclui informações de fuso horário.The DateTime.Parse overloads return a DateTime value whose Kind property includes time zone information. Isso pode indicar que a hora é:It can indicate that the time is:

Em geral, Parse o método retorna DateTime um objeto Kind cuja propriedade DateTimeKind.Unspecifiedé.Generally, the Parse method returns a DateTime object whose Kind property is DateTimeKind.Unspecified. No entanto Parse , o método também pode executar a conversão de fuso horário e definir Kind o valor da propriedade de forma diferente, dependendo dos s valores styles dos parâmetros e:However, the Parse method may also perform time zone conversion and set the value of the Kind property differently, depending on the values of the s and styles parameters:

IfIf Conversão de fuso horárioTime zone conversion Propriedade de tipoKind property
scontém informações de fuso horário.s contains time zone information. A data e hora são convertidas na hora no fuso horário local.The date and time is converted to the time in the local time zone. DateTimeKind.Local
scontém informações de fuso horário e styles inclui o AdjustToUniversal sinalizador.s contains time zone information, and styles includes the AdjustToUniversal flag. A data e a hora são convertidas em UTC (tempo Universal Coordenado).The date and time is converted to Coordinated Universal Time (UTC). DateTimeKind.Utc
scontém o designador de fuso horário Z ou GMT e styles inclui o RoundtripKind sinalizador.s contains the Z or GMT time zone designator, and styles includes the RoundtripKind flag. A data e a hora são interpretadas como UTC.The date and time are interpreted as UTC. DateTimeKind.Utc

O exemplo a seguir converte as cadeias de caracteres de data que contêm informações de fuso horário na hora no fuso horário local:The following example converts date strings that contain time zone information to the time in the local time zone:

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                                             
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 Kind propriedade de data e hora durante uma operação de formatação e de análise usando o DateTimeStyles.RoundtripKind sinalizador.You can also preserve the value of a date and time's Kind property during a formatting and parsing operation by using the DateTimeStyles.RoundtripKind flag. O exemplo a seguir ilustra como RoundtripKind o sinalizador afeta a operação de análise DateTime em valores que são convertidos em cadeias de caracteres usando o especificador de formato "o", "r" ou "u".The following example illustrates how the RoundtripKind flag affects the parsing operation on DateTime values that are converted to strings by using the "o", "r", or "u" format specifier.

   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.      
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) Parse(String) Parse(String) 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 do thread atual.Converts the string representation of a date and time to its DateTime equivalent by using the conventions of the current thread culture.

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 String String String

Uma cadeia de caracteres que contém uma data e hora a ser convertida.A string that contains a date and time to convert. Confira a cadeia de caracteres a ser analisada para obter mais informações.See The string to parse for more information.

Retornos

Um objeto equivalente à data e hora contida no s.An object that is equivalent to the date and time contained in s.

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.s does not contain a valid string representation of a date and time.

Comentários

Se s contiver informações de fuso horário, esse método DateTime retornará um Kind valor cuja DateTimeKind.Local Propriedade seja e converterá a data s e a hora em na hora local.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. Caso contrário, ele não executa nenhuma conversão de fuso horário DateTime e retorna Kind um valor DateTimeKind.Unspecifiedcuja propriedade é.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Essa sobrecarga tenta analisar s usando as convenções de formatação da cultura atual.This overload attempts to parse s by using the formatting conventions of the current culture. A cultura atual é indicada pela CurrentCulture propriedade.The current culture is indicated by the CurrentCulture property. Para analisar uma cadeia de caracteres usando as convenções de formatação de uma cultura específica Parse(String, IFormatProvider) , chame Parse(String, IFormatProvider, DateTimeStyles) ou as sobrecargas.To parse a string using the formatting conventions of a specific culture, call the Parse(String, IFormatProvider) or the Parse(String, IFormatProvider, DateTimeStyles) overloads.

Essa sobrecarga tenta analisar s usando DateTimeStyles.AllowWhiteSpaces Style.This overload attempts to parse s by using DateTimeStyles.AllowWhiteSpaces style.

ExemploExample

O exemplo a seguir analisa a representação de cadeia de caracteres de vários valores de data e hora por:The following example parses the string representation of several date and time values by:

  • Usando o provedor de formato padrão, que fornece as convenções de formatação da cultura de thread atual do computador usado para produzir a saída de exemplo.Using the default format provider, which provides the formatting conventions of the current thread culture of the computer used to produce the example output. A saída deste exemplo reflete as convenções de formatação da cultura en-US.The output from this example reflects the formatting conventions of the en-US culture.

  • Usando o valor de estilo padrão, que AllowWhiteSpacesé.Using the default style value, which is AllowWhiteSpaces.

Ele manipula a FormatException exceção que é lançada quando o método tenta analisar a representação da cadeia de caracteres de uma data e hora usando algumas convenções de formatação de outras culturas.It handles the FormatException exception that is thrown when the method tries to parse the string representation of a date and time by using some other culture's formatting conventions. 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 de thread atual.It also shows how to successfully parse a date and time value that does not use the formatting conventions of the current thread culture.

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.
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.
Veja também

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information.

public:
 static DateTime Parse(System::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 String String String

Uma cadeia de caracteres que contém uma data e hora a ser convertida.A string that contains a date and time to convert. Confira a cadeia de caracteres a ser analisada para obter mais informações.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Um objeto que fornece informações de formato específicas de cultura sobre s.An object that supplies culture-specific format information about s. Confira Convenções culturais e análiseSee Parsing and cultural conventions

Retornos

Um objeto equivalente à data e à hora contidas no s, conforme especificado por provider.An object that is equivalent to the date and time contained in s as specified by provider.

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.s does not contain a valid string representation of a date and time.

Comentários

Se s contiver informações de fuso horário, esse método DateTime retornará um Kind valor cuja DateTimeKind.Local Propriedade seja e converterá a data s e a hora em na hora local.If s contains time zone information, this method returns a DateTime value whose Kind property is DateTimeKind.Local and converts the date and time in s to local time. Caso contrário, ele não executa nenhuma conversão de fuso horário DateTime e retorna Kind um valor DateTimeKind.Unspecifiedcuja propriedade é.Otherwise, it performs no time zone conversion and returns a DateTime value whose Kind property is DateTimeKind.Unspecified.

Essa sobrecarga tenta analisar s usando o DateTimeStyles.AllowWhiteSpaces estilo.This overload attempts to parse s by using the DateTimeStyles.AllowWhiteSpaces style.

ExemploExample

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-DE.The following example parses an array of date strings by using the conventions of the en-US, fr-FR, and de-DE cultures. Ele demonstra que as representações de cadeia de caracteres de uma única data podem ser interpretadas diferentemente entre diferentes culturas.It demonstrates that the string representations of a single date can be interpreted differently across different cultures.

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.
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.
Veja também

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles) 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.Converts a memory span that contains string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

public static DateTime Parse (ReadOnlySpan<char> s, IFormatProvider provider = null, 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 = null, 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.The memory span that contains the string to parse. Confira a cadeia de caracteres a ser analisada para obter mais informações.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Um objeto que fornece informações de formato específicas de cultura sobre s.An object that supplies culture-specific format information about s. Confira Convenções culturais e análiseSee Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles 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.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Um valor típico a ser especificado é None.A typical value to specify is None.

Retornos

Um objeto equivalente à data e hora contida no s, conforme especificado por provider e styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.s does not contain a valid string representation of a date and time.

styles contém uma combinação inválida de valores DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Por exemplo, AssumeLocal e AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) Parse(String, IFormatProvider, DateTimeStyles) 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.Converts the string representation of a date and time to its DateTime equivalent by using culture-specific format information and a formatting style.

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);
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 String String String

Uma cadeia de caracteres que contém uma data e hora a ser convertida.A string that contains a date and time to convert. Confira a cadeia de caracteres a ser analisada para obter mais informações.See The string to parse for more information.

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Um objeto que fornece informações de formatação específicas de cultura sobre s.An object that supplies culture-specific formatting information about s. Confira Convenções culturais e análiseSee Parsing and cultural conventions

styles
DateTimeStyles DateTimeStyles DateTimeStyles 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.A bitwise combination of the enumeration values that indicates the style elements that can be present in s for the parse operation to succeed, and that defines how to interpret the parsed date in relation to the current time zone or the current date. Um valor típico a ser especificado é None.A typical value to specify is None.

Retornos

Um objeto equivalente à data e hora contida no s, conforme especificado por provider e styles.An object that is equivalent to the date and time contained in s, as specified by provider and styles.

Exceções

s não contém uma representação da cadeia de caracteres válida de uma data e hora.s does not contain a valid string representation of a date and time.

styles contém uma combinação inválida de valores DateTimeStyles.styles contains an invalid combination of DateTimeStyles values. Por exemplo, AssumeLocal e AssumeUniversal.For example, both AssumeLocal and AssumeUniversal.

Comentários

Essa sobrecarga de método converte a data e a s hora em e Kind define a propriedade do DateTime valor retornado da seguinte maneira:This method overload converts the date and time in s and sets the Kind property of the returned DateTime value as follows:

IfIf Conversão de fuso horárioTime zone conversion Propriedade de tipoKind property
sNão contém informações de fuso horário.s contains no time zone information. nenhuma.None. DateTimeKind.Unspecified
scontém informações de fuso horário.s contains time zone information. Até o horário no fuso horário localTo the time in the local time zone DateTimeKind.Local
scontém informações de fuso horário e ' estilos inclui o DateTimeStyles.AdjustToUniversal sinalizador.s contains time zone information, and `styles includes the DateTimeStyles.AdjustToUniversal flag. Para tempo universal coordenado (UTC)To Coordinated Universal Time (UTC) DateTimeKind.Utc
scontém o designador de fuso horário Z ou GMT e styles inclui o DateTimeStyles.RoundtripKind.s contains the Z or GMT time zone designator, and styles includes the DateTimeStyles.RoundtripKind. nenhuma.None. Utc

ExemploExample

O exemplo a seguir demonstra Parse(String, IFormatProvider, DateTimeStyles) o método e exibe o valor Kind da propriedade dos valores resultantes DateTime .The following example demonstrates the Parse(String, IFormatProvider, DateTimeStyles) method and displays the value of the Kind property of the resulting DateTime values.

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.
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.
Veja também

Aplica-se a