DateTimeFormatInfo Classe

Definição

Fornece informações específicas da cultura sobre o formato dos valores de data e hora.

public ref class DateTimeFormatInfo sealed : IFormatProvider
public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider
public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider, System::Runtime::Serialization::ISerializable
public sealed class DateTimeFormatInfo : IFormatProvider
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider, System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider, ISerializable
Herança
DateTimeFormatInfo
Atributos
Implementações

Exemplos

O exemplo a seguir usa reflexão para obter as propriedades do DateTimeFormatInfo objeto para a cultura em inglês (Estados Unidos). Ele exibe o valor dessas propriedades que contêm cadeias de caracteres de formato personalizado e usa essas cadeias de caracteres para exibir datas formatadas.

using System;
using System.Globalization;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get the properties of an en-US DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo("en-US").DateTimeFormat;
      Type typ = dtfi.GetType();
      PropertyInfo[] props = typ.GetProperties();
      DateTime value = new DateTime(2012, 5, 28, 11, 35, 0);

      foreach (var prop in props) {
         // Is this a format pattern-related property?
         if (prop.Name.Contains("Pattern")) {
            string fmt = prop.GetValue(dtfi, null).ToString();
            Console.WriteLine("{0,-33} {1} \n{2,-37}Example: {3}\n",
                              prop.Name + ":", fmt, "",
                              value.ToString(fmt));
         }
      }
   }
}
// The example displays the following output:
//    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
//                                         Example: Monday, May 28, 2012 11:35:00 AM
//
//    LongDatePattern:                  dddd, MMMM dd, yyyy
//                                         Example: Monday, May 28, 2012
//
//    LongTimePattern:                  h:mm:ss tt
//                                         Example: 11:35:00 AM
//
//    MonthDayPattern:                  MMMM dd
//                                         Example: May 28
//
//    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
//                                         Example: Mon, 28 May 2012 11:35:00 GMT
//
//    ShortDatePattern:                 M/d/yyyy
//                                         Example: 5/28/2012
//
//    ShortTimePattern:                 h:mm tt
//                                         Example: 11:35 AM
//
//    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
//                                         Example: 2012-05-28T11:35:00
//
//    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
//                                         Example: 2012-05-28 11:35:00Z
//
//    YearMonthPattern:                 MMMM, yyyy
//                                         Example: May, 2012
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get the properties of an en-US DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo("en-US").DateTimeFormat
      Dim typ As Type = dtfi.GetType()
      Dim props() As PropertyInfo = typ.GetProperties()
      Dim value As Date = #05/28/2012 11:35AM# 
      
      For Each prop In props
         ' Is this a format pattern-related property?
         If prop.Name.Contains("Pattern") Then
            Dim fmt As String = CStr(prop.GetValue(dtfi, Nothing))
            Console.WriteLine("{0,-33} {1} {2}{3,-37}Example: {4}", 
                              prop.Name + ":", fmt, vbCrLf, "",
                              value.ToString(fmt)) 
            Console.WriteLine()
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
'                                         Example: Monday, May 28, 2012 11:35:00 AM
'    
'    LongDatePattern:                  dddd, MMMM dd, yyyy
'                                         Example: Monday, May 28, 2012
'    
'    LongTimePattern:                  h:mm:ss tt
'                                         Example: 11:35:00 AM
'    
'    MonthDayPattern:                  MMMM dd
'                                         Example: May 28
'    
'    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
'                                         Example: Mon, 28 May 2012 11:35:00 GMT
'    
'    ShortDatePattern:                 M/d/yyyy
'                                         Example: 5/28/2012
'    
'    ShortTimePattern:                 h:mm tt
'                                         Example: 11:35 AM
'    
'    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
'                                         Example: 2012-05-28T11:35:00
'    
'    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
'                                         Example: 2012-05-28 11:35:00Z
'    
'    YearMonthPattern:                 MMMM, yyyy
'                                         Example: May, 2012

Comentários

As propriedades da DateTimeFormatInfo classe contêm informações específicas da cultura para formatação ou análise de valores de data e hora, como o seguinte:

  • Os padrões usados para formatar valores de data.

  • Os padrões usados para formatar valores de tempo.

  • Os nomes dos dias da semana.

  • Os nomes dos meses do ano.

  • The A.M. e P.M. designadores usados em valores de tempo.

  • O calendário no qual as datas são expressas.

Nesta seção:

Criando uma instância de um objeto DateTimeFormatInfo

Um DateTimeFormatInfo objeto pode representar as convenções de formatação da cultura invariável, uma cultura específica, uma cultura neutra ou a cultura atual. Esta seção discute como instanciar cada tipo de DateTimeFormatInfo objeto.

Criando uma instância de um objeto DateTimeFormatInfo para a cultura invariável

A cultura invariável representa uma cultura insensível. Ele é baseado no idioma inglês, mas não em qualquer país/região de língua inglesa específico. Embora os dados de culturas específicas possam ser dinâmicos e possam ser alterados para refletir novas convenções culturais ou preferências do usuário, os dados da cultura invariável não mudam. Você pode criar uma instância de um DateTimeFormatInfo objeto que representa as convenções de formatação da cultura invariável das seguintes maneiras:

O exemplo a seguir usa cada um desses métodos para criar uma instância de um DateTimeFormatInfo objeto que representa a cultura invariável. Em seguida, indica se o objeto é somente leitura.

System.Globalization.DateTimeFormatInfo dtfi;

dtfi = System.Globalization.DateTimeFormatInfo.InvariantInfo;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = new System.Globalization.DateTimeFormatInfo();
Console.WriteLine(dtfi.IsReadOnly);

dtfi = System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//       True
//       False
//       True
Dim dtfi As System.Globalization.DateTimeFormatInfo

dtfi = System.Globalization.DateTimeFormatInfo.InvariantInfo
Console.WriteLine(dtfi.IsReadOnly)               

dtfi = New System.Globalization.DateTimeFormatInfo()
Console.WriteLine(dtfi.IsReadOnly)               

dtfi = System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat
Console.WriteLine(dtfi.IsReadOnly) 
' The example displays the following output:
'       True
'       False
'       True

Criando uma instância de um objeto DateTimeFormatInfo para uma cultura específica

Uma cultura específica representa uma linguagem falada em um determinado país/região. Por exemplo, en-US é uma cultura específica que representa o idioma inglês falado no Estados Unidos, e en-CA é uma cultura específica que representa o idioma inglês falado no Canadá. Você pode criar uma instância de um DateTimeFormatInfo objeto que representa as convenções de formatação de uma cultura específica das seguintes maneiras:

O exemplo a seguir ilustra cada uma dessas maneiras de instanciar um DateTimeFormatInfo objeto e indica se o objeto resultante é somente leitura.

System.Globalization.CultureInfo ci = null;
System.Globalization.DateTimeFormatInfo dtfi = null;

// Instantiate a culture using CreateSpecificCulture.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-US");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a culture using the CultureInfo constructor.
ci = new System.Globalization.CultureInfo("en-CA");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", ci.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
ci = System.Globalization.CultureInfo.GetCultureInfo("en-AU");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling DateTimeFormatInfo.GetInstance.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(ci);
Console.WriteLine("{0} from GetInstance: {1}", ci.Name, dtfi.IsReadOnly);

// The example displays the following output:
//      en-US from CreateSpecificCulture: False
//      en-CA from CultureInfo constructor: False
//      en-AU from GetCultureInfo: True
//      en-GB from GetInstance: False
Dim ci As System.Globalization.CultureInfo = Nothing
Dim dtfi As System.Globalization.DateTimeFormatInfo = Nothing

' Instantiate a culture using CreateSpecificCulture.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-US")
dtfi = ci.DateTimeFormat
Console.WriteLine("{0} from CreateSpecificCulture: {1}", ci.Name, dtfi.IsReadOnly)

' Instantiate a culture using the CultureInfo constructor.
ci = new System.Globalization.CultureInfo("en-CA") 
dtfi = ci.DateTimeFormat
Console.WriteLine("{0} from CultureInfo constructor: {1}", ci.Name, dtfi.IsReadOnly)

' Retrieve a culture by calling the GetCultureInfo method.
ci = System.Globalization.CultureInfo.GetCultureInfo("en-AU")
dtfi = ci.DateTimeFormat
Console.WriteLine("{0} from GetCultureInfo: {1}", ci.Name, dtfi.IsReadOnly)


' Instantiate a DateTimeFormatInfo object by calling DateTimeFormatInfo.GetInstance.  
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB")
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(ci)
Console.WriteLine("{0} from GetInstance: {1}", ci.Name, dtfi.IsReadOnly)

' The example displays the following output:
'      en-US from CreateSpecificCulture: False
'      en-CA from CultureInfo constructor: False
'      en-AU from GetCultureInfo: True
'      en-GB from GetInstance: False

Criando uma instância de um objeto DateTimeFormatInfo para uma cultura neutra

Uma cultura neutra representa uma cultura ou idioma independente de um país/região; normalmente é o pai de uma ou mais culturas específicas. Por exemplo, Fr é uma cultura neutra para o idioma francês e o pai da cultura fr-FR. Você pode criar uma instância de um DateTimeFormatInfo objeto que representa as convenções de formatação de uma cultura neutra da mesma forma que você cria um DateTimeFormatInfo objeto que representa as convenções de formatação de uma cultura específica. Além disso, você pode recuperar o objeto de DateTimeFormatInfo uma cultura neutra recuperando uma cultura neutra da propriedade de CultureInfo.Parent uma cultura específica e recuperando o DateTimeFormatInfo objeto retornado por sua CultureInfo.DateTimeFormat propriedade. A menos que a cultura pai represente a cultura invariável, o objeto retornado DateTimeFormatInfo será leitura/gravação. O exemplo a seguir ilustra essas maneiras de instanciar um DateTimeFormatInfo objeto que representa uma cultura neutra.

System.Globalization.CultureInfo specific, neutral;
System.Globalization.DateTimeFormatInfo dtfi;

// Instantiate a culture by creating a specific culture and using its Parent property.
specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR");
neutral = specific.Parent;
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a neutral culture using the CultureInfo constructor.
neutral = new System.Globalization.CultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a culture using CreateSpecificCulture.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
neutral = System.Globalization.CultureInfo.GetCultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling GetInstance.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral);
Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly);

// The example displays the following output:
//       fr from Parent property: False
//       fr from Parent property: False
//       fr from CultureInfo constructor: False
//       fr-FR from CreateSpecificCulture: False
//       fr from GetCultureInfo: True
//       fr-FR from GetInstance: False
 Dim specific, neutral As System.Globalization.CultureInfo
 Dim dtfi As System.Globalization.DateTimeFormatInfo

 ' Instantiate a culture by creating a specific culture and using its Parent property.
 specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR")
 neutral = specific.Parent
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly)
 
 dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat
 Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly)

 ' Instantiate a neutral culture using the CultureInfo constructor.
 neutral = New System.Globalization.CultureInfo("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly)

 ' Instantiate a culture using CreateSpecificCulture. 
 neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly)
 
 ' Retrieve a culture by calling the GetCultureInfo method.
 neutral = System.Globalization.CultureInfo.GetCultureInfo("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly)
 
 ' Instantiate a DateTimeFormatInfo object by calling GetInstance.  
 neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
 dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral)
 Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly)

 ' The example displays the following output:
 '       fr from Parent property: False
 '       fr from Parent property: False
 '       fr from CultureInfo constructor: False
 '       fr-FR from CreateSpecificCulture: False
 '       fr from GetCultureInfo: True
 '       fr-FR from GetInstance: False

Observação

No .NET Framework versões 1.0 a .NET Framework 3.5, tentar recuperar um DateTimeFormatInfo objeto que reflete as convenções de formatação de uma cultura neutra gera uma NotSupportedException exceção.

No entanto, uma cultura neutra não tem informações de formatação específicas da cultura, pois é independente de um país/região específico. Em vez de preencher o DateTimeFormatInfo objeto com valores genéricos, o .NET Framework retorna um DateTimeFormatInfo objeto que reflete as convenções de formatação de uma cultura específica que é filho da cultura neutra. Por exemplo, o DateTimeFormatInfo objeto para a cultura en neutra reflete as convenções de formatação da cultura en-US, e o DateTimeFormatInfo objeto para a cultura fr reflete as convenções de formatação da cultura fr-FR.

Você pode usar código como o seguinte para determinar quais convenções de formatação de cultura específica uma cultura neutra representa. O exemplo usa reflexão para comparar as DateTimeFormatInfo propriedades de uma cultura neutra com as propriedades de uma cultura filho específica. Ele considera dois calendários equivalentes se forem do mesmo tipo de calendário e, para calendários gregorianos, se suas propriedades tiverem GregorianCalendar.CalendarType valores idênticos.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get all the neutral cultures
      List<String> names = new List<String>();
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    culture => names.Add(culture.Name));
      names.Sort();
      foreach (var name in names) {
         // Ignore the invariant culture.
         if (name == "") continue;

         ListSimilarChildCultures(name);
      }
   }

   private static void ListSimilarChildCultures(String name)
   {
      // Create the neutral DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo(name).DateTimeFormat;
      // Retrieve all specific cultures of the neutral culture.
      CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
                               culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
      // Create an array of DateTimeFormatInfo properties
      PropertyInfo[] properties = typeof(DateTimeFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
      bool hasOneMatch = false;

      foreach (var ci in cultures) {
         bool match = true;
         // Get the DateTimeFormatInfo for a specific culture.
         DateTimeFormatInfo specificDtfi = ci.DateTimeFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.
            if (prop.Name == "IsReadOnly") continue;

            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) {
               IList nList = (IList) prop.GetValue(dtfi, null);
               IList sList = (IList) prop.GetValue(specificDtfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name);
                  break;
               }

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) {
                     match = false;
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name);
                     break;
                  }
               }

               if (! match) break;
            }
            // Get non-array values.
            else {
               Object specificValue = prop.GetValue(specificDtfi);
               Object neutralValue = prop.GetValue(dtfi);

               // Handle comparison of Calendar objects.
               if (prop.Name == "Calendar") {
                  // The cultures have a different calendar type.
                  if (specificValue.ToString() != neutralValue.ToString()) {
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name);
                     match = false;
                     break;
                  }

                  if (specificValue is GregorianCalendar) {
                     if (((GregorianCalendar) specificValue).CalendarType != ((GregorianCalendar) neutralValue).CalendarType) {
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name);
                        match = false;
                        break;
                     }
                  }
               }
               else if (! specificValue.Equals(neutralValue)) {
                  match = false;
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name);
                  break;
               }
            }
         }
         if (match) {
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'",
                              name, ci.Name);
            hasOneMatch = true;
         }
      }
      if (! hasOneMatch)
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name);

      Console.WriteLine();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get all the neutral cultures
      Dim names As New List(Of String)
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    Sub(culture) names.Add(culture.Name))
      names.Sort()
      For Each name In names
         ' Ignore the invariant culture.
         If name = "" Then Continue For
         
         ListSimilarChildCultures(name)        
      Next
   End Sub

   Private Sub ListSimilarChildCultures(name As String)
      ' Create the neutral DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo(name).DateTimeFormat
      ' Retrieve all specific cultures of the neutral culture.
      Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
      ' Create an array of DateTimeFormatInfo properties
      Dim properties() As PropertyInfo = GetType(DateTimeFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
      Dim hasOneMatch As Boolean = False

      For Each ci In cultures
         Dim match As Boolean = True     
         ' Get the DateTimeFormatInfo for a specific culture.
         Dim specificDtfi As DateTimeFormatInfo = ci.DateTimeFormat
         ' Compare the property values of the two.
         For Each prop In properties
            ' We're not interested in the value of IsReadOnly.     
            If prop.Name = "IsReadOnly" Then Continue For
            
            ' For arrays, iterate the individual elements to see if they are the same.
            If prop.PropertyType.IsArray Then 
               Dim nList As IList = CType(prop.GetValue(dtfi, Nothing), IList)
               Dim sList As IList = CType(prop.GetValue(specificDtfi, Nothing), IList)
               If nList.Count <> sList.Count Then
                  match = false
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name)
                  Exit For
               End If 

               For ctr As Integer = 0 To nList.Count - 1
                  If Not nList(ctr).Equals(sList(ctr)) 
                     match = false
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name)                     
                     Exit For
                  End If     
               Next
               
               If Not match Then Exit For
            ' Get non-array values.
            Else
               Dim specificValue As Object = prop.GetValue(specificDtfi)
               Dim neutralValue As Object = prop.GetValue(dtfi)
                               
               ' Handle comparison of Calendar objects.
               If prop.Name = "Calendar" Then 
                  ' The cultures have a different calendar type.
                  If specificValue.ToString() <> neutralValue.ToString() Then
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name)
                     match = False
                     Exit For
                  End If
                   
                  If TypeOf specificValue Is GregorianCalendar Then
                     If CType(specificValue, GregorianCalendar).CalendarType <> CType(neutralValue, GregorianCalendar).CalendarType Then
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name)
                        match = False
                        Exit For
                     End If
                  End If
               Else If Not specificValue.Equals(neutralValue) Then
                  match = false
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name)                  
                  Exit For   
               End If
            End If        
         Next
         If match Then
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name)
            hasOneMatch = True
         End If                                       
      Next
      If Not hasOneMatch Then
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name)            
      End If
      
      Console.WriteLine()
   End Sub
End Module

Criando uma instância de um objeto DateTimeFormatInfo para a cultura atual

Você pode criar uma instância de um DateTimeFormatInfo objeto que representa as convenções de formatação da cultura atual das seguintes maneiras:

O exemplo a seguir usa cada um desses métodos para criar uma instância de um DateTimeFormatInfo objeto que representa as convenções de formatação da cultura atual. Em seguida, indica se o objeto é somente leitura.

DateTimeFormatInfo dtfi;

dtfi = DateTimeFormatInfo.CurrentInfo;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = CultureInfo.CurrentCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture);
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//     True
//     True
//     True
Dim dtfi As DateTimeFormatInfo

dtfi = DateTimeFormatInfo.CurrentInfo
Console.WriteLine(dtfi.IsReadOnly)

dtfi = CultureInfo.CurrentCulture.DateTimeFormat
Console.WriteLine(dtfi.IsReadOnly)

dtfi = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture)
Console.WriteLine(dtfi.IsReadOnly)
' The example displays the following output:
'     True
'     True
'     True

Você pode criar um objeto gravável DateTimeFormatInfo que representa as convenções da cultura atual de uma destas maneiras:

O exemplo a seguir ilustra cada forma de instanciar um objeto de leitura/gravação DateTimeFormatInfo e exibe o valor de sua IsReadOnly propriedade.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTimeFormatInfo current1 = DateTimeFormatInfo.CurrentInfo;
      current1 = (DateTimeFormatInfo) current1.Clone();
      Console.WriteLine(current1.IsReadOnly);

      CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
      DateTimeFormatInfo current2 = culture2.DateTimeFormat;
      Console.WriteLine(current2.IsReadOnly);
   }
}
// The example displays the following output:
//       False
//       False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As DateTimeFormatInfo = DateTimeFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), DateTimeFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As DateTimeFormatInfo = culture2.DateTimeFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

Em Windows, o usuário pode substituir alguns dos valores de DateTimeFormatInfo propriedade usados em operações de formatação e análise por meio do aplicativo Região e Idioma em Painel de Controle. Por exemplo, um usuário cuja cultura é inglês (Estados Unidos) pode optar por exibir valores de tempo longo usando um relógio de 24 horas (no formato HH:mm:ss) em vez do relógio padrão de 12 horas (no formato h:mm:ss tt). Os DateTimeFormatInfo objetos recuperados das maneiras discutidas anteriormente refletem essas substituições de usuário. Se isso for indesejável, você poderá criar um NumberFormatInfo objeto que não reflete as substituições do usuário (e também é leitura/gravação em vez de somente leitura) chamando o CultureInfo.CultureInfo(String, Boolean) construtor e fornecendo um valor false para o useUserOverride argumento. O exemplo a seguir ilustra isso para um sistema cuja cultura atual é inglês (Estados Unidos) e cujo padrão de longo tempo foi alterado do padrão de h:mm:ss tt para HH:mm:ss.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      DateTimeFormatInfo dtfi;

      culture = CultureInfo.CurrentCulture;
      dtfi = culture.DateTimeFormat;
      Console.WriteLine("Culture Name:      {0}", culture.Name);
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride);
      Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);

      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:      {0}",   culture.Name);
      Console.WriteLine("User Overrides:    {0}",   culture.UseUserOverride);
      Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);
   }
}
// The example displays the following output:
//       Culture Name:      en-US
//       User Overrides:    True
//       Long Time Pattern: HH:mm:ss
//
//       Culture Name:      en-US
//       User Overrides:    False
//       Long Time Pattern: h:mm:ss tt
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim dtfi As DateTimeFormatInfo
      
      culture = CultureInfo.CurrentCulture
      dtfi = culture.DateTimeFormat
      Console.WriteLine("Culture Name:      {0}", culture.Name)
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride)
      Console.WriteLine("Long Time Pattern: {0}", culture.DateTimeFormat.LongTimePattern)
      Console.WriteLine()
            
      culture = New CultureInfo(CultureInfo.CurrentCulture.Name, False)
      Console.WriteLine("Culture Name:      {0}", culture.Name)
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride)
      Console.WriteLine("Long Time Pattern: {0}", culture.DateTimeFormat.LongTimePattern)
   End Sub
End Module
' The example displays the following output:
'       Culture Name:      en-US
'       User Overrides:    True
'       Long Time Pattern: HH:mm:ss
'       
'       Culture Name:      en-US
'       User Overrides:    False
'       Long Time Pattern: h:mm:ss tt

DateTimeFormatInfo e dados dinâmicos

Os dados específicos da cultura para formatação de valores de data e hora fornecidos pela DateTimeFormatInfo classe são dinâmicos, assim como os dados culturais fornecidos pela CultureInfo classe. Você não deve fazer nenhuma suposição sobre a estabilidade dos valores para DateTimeFormatInfo objetos associados a objetos específicos CultureInfo . Somente os dados fornecidos pela cultura invariável e seu objeto associado DateTimeFormatInfo são estáveis. Outros dados podem ser alterados entre sessões de aplicativo ou até mesmo enquanto seu aplicativo está em execução. Há quatro fontes principais de alteração:

  • Atualizações do sistema. As preferências culturais, como o calendário preferencial ou os formatos personalizados de data e hora, mudam ao longo do tempo. Quando isso acontece, Windows Update inclui alterações no valor da DateTimeFormatInfo propriedade para uma cultura específica.

  • Culturas de substituição. A CultureAndRegionInfoBuilder classe pode ser usada para substituir os dados de uma cultura existente.

  • Alterações em cascata nos valores da propriedade. Várias propriedades relacionadas à cultura podem ser alteradas em tempo de execução, o que, por sua vez, faz com que os dados sejam alterados DateTimeFormatInfo . Por exemplo, a cultura atual pode ser alterada programaticamente ou por meio da ação do usuário. Quando isso acontece, o DateTimeFormatInfo objeto retornado pela CurrentInfo propriedade é alterado para um objeto associado à cultura atual. Da mesma forma, o calendário de uma cultura pode ser alterado, o que pode resultar em alterações em vários DateTimeFormatInfo valores de propriedade.

  • Preferências do usuário. Os usuários do aplicativo podem optar por substituir alguns dos valores associados à cultura do sistema atual por meio das opções regionais e de idioma no Painel de Controle. Por exemplo, os usuários podem optar por exibir a data em um formato diferente. Se a CultureInfo.UseUserOverride propriedade estiver definida como true, as propriedades do DateTimeFormatInfo objeto também serão recuperadas das configurações do usuário. Se as configurações do usuário forem incompatíveis com a cultura associada CultureInfo ao objeto (por exemplo, se o calendário selecionado não for um dos calendários indicados pela OptionalCalendars propriedade), os resultados dos métodos e os valores das propriedades serão indefinidos.

Para minimizar a possibilidade de dados inconsistentes, todas as propriedades substituíveis pelo usuário de um DateTimeFormatInfo objeto são inicializadas quando o objeto é criado. Ainda há uma possibilidade de inconsistência, pois nem a criação de objeto nem o processo de substituição do usuário são atômicos e os valores relevantes podem ser alterados durante a criação do objeto. No entanto, essa situação deve ser extremamente rara.

Você pode controlar se as substituições de usuário são refletidas em DateTimeFormatInfo objetos que representam a mesma cultura que a cultura do sistema. A tabela a seguir lista as maneiras pelas quais um DateTimeFormatInfo objeto pode ser recuperado e indica se o objeto resultante reflete as substituições do usuário.

Origem do objeto CultureInfo e DateTimeFormatInfo Reflete as substituições do usuário
Propriedade CultureInfo.CurrentCulture.DateTimeFormat Sim
Propriedade DateTimeFormatInfo.CurrentInfo Sim
Método CultureInfo.CreateSpecificCulture Sim
Método CultureInfo.GetCultureInfo Não
Construtor CultureInfo.CultureInfo(String) Sim
Construtor CultureInfo.CultureInfo(String, Boolean) Depende do valor do useUserOverride parâmetro

A menos que haja um motivo convincente para fazer o contrário, você deve respeitar as substituições do usuário ao usar o DateTimeFormatInfo objeto em aplicativos cliente para formatar e analisar a entrada do usuário ou exibir dados. Para aplicativos de servidor ou aplicativos autônomos, você não deve. No entanto, se você estiver usando o DateTimeFormatInfo objeto explicitamente ou implicitamente para persistir dados de data e hora no formulário de cadeia de caracteres, deverá usar um DateTimeFormatInfo objeto que reflita as convenções de formatação da cultura invariável ou especifique uma cadeia de caracteres de formato de data e hora personalizada que você usa independentemente da cultura.

Formatando datas e horas

Um DateTimeFormatInfo objeto é usado implicitamente ou explicitamente em todas as operações de formatação de data e hora. Elas incluem chamadas para os seguintes métodos:

Todas as operações de formatação de data e hora usam uma implementação IFormatProvider . A IFormatProvider interface inclui um único método. IFormatProvider.GetFormat(Type) Esse método de retorno de chamada é passado por um Type objeto que representa o tipo necessário para fornecer informações de formatação. O método retorna uma instância desse tipo ou null se não pode fornecer uma instância do tipo. O .NET Framework inclui duas IFormatProvider implementações para formatação de datas e horas:

Se uma IFormatProvider implementação não for fornecida a um método de formatação explicitamente, o CultureInfo objeto retornado pela CultureInfo.CurrentCulture propriedade que representa a cultura atual será usado.

O exemplo a seguir ilustra a relação entre a IFormatProvider interface e a DateTimeFormatInfo classe em operações de formatação. Ele define uma implementação personalizada IFormatProvider cujo GetFormat método exibe o tipo do objeto solicitado pela operação de formatação. Se ele estiver solicitando um DateTimeFormatInfo objeto, o método fornecerá o DateTimeFormatInfo objeto para a cultura atual. Como mostra a saída do exemplo, o Decimal.ToString(IFormatProvider) método solicita um DateTimeFormatInfo objeto para fornecer informações de formatação, enquanto o String.Format(IFormatProvider, String, Object[]) método solicita NumberFormatInfo e DateTimeFormatInfo objetos, bem como uma implementação ICustomFormatter .

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
   public Object GetFormat(Type formatType)
   {
      Console.WriteLine("Requesting an object of type {0}",
                        formatType.Name);
      if (formatType == typeof(NumberFormatInfo))
         return NumberFormatInfo.CurrentInfo;
      else if (formatType == typeof(DateTimeFormatInfo))
         return DateTimeFormatInfo.CurrentInfo;
      else
         return null;
   }
}

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 28, 13, 30, 0);
      string value = dateValue.ToString("F", new CurrentCultureFormatProvider());
      Console.WriteLine(value);
      Console.WriteLine();
      string composite = String.Format(new CurrentCultureFormatProvider(),
                                       "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                       dateValue, 1264.03m, "Service Charge");
      Console.WriteLine(composite);
      Console.WriteLine();
   }
}
// The example displays output like the following:
//       Requesting an object of type DateTimeFormatInfo
//       Tuesday, May 28, 2013 1:30:00 PM
//
//       Requesting an object of type ICustomFormatter
//       Requesting an object of type DateTimeFormatInfo
//       Requesting an object of type NumberFormatInfo
//       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge
Imports System.Globalization

Public Class CurrentCultureFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name)
      If formatType Is GetType(NumberFormatInfo) Then
         Return NumberFormatInfo.CurrentInfo
      Else If formatType Is GetType(DateTimeFormatInfo) Then
         Return DateTimeFormatInfo.CurrentInfo
      Else
         Return Nothing
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 05, 28, 13, 30, 0)
      Dim value As String = dateValue.ToString("F", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                              dateValue, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'       Requesting an object of type DateTimeFormatInfo
'       Tuesday, May 28, 2013 1:30:00 PM
'       
'       Requesting an object of type ICustomFormatter
'       Requesting an object of type DateTimeFormatInfo
'       Requesting an object of type NumberFormatInfo
'       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge

Cadeias de caracteres de formato e propriedades DateTimeFormatInfo

O DateTimeFormatInfo objeto inclui três tipos de propriedades que são usadas em operações de formatação com valores de data e hora:

As cadeias de caracteres de formato de data e hora padrão, como "d", "D", "f" e "F", são aliases que correspondem a propriedades de padrão de formato específicas DateTimeFormatInfo . A maioria das cadeias de caracteres de formato de data e hora personalizadas está relacionada a cadeias de caracteres ou subcadeias de caracteres que uma operação de formatação insere no fluxo de resultados. A tabela a seguir lista os especificadores de formato de data e hora padrão e personalizados e suas propriedades associadas DateTimeFormatInfo . Para obter detalhes sobre como usar esses especificadores de formato, consulte Cadeias de caracteres de formato de data e hora padrão e cadeias de caracteres de formato de data e hora personalizadas. Observe que cada cadeia de caracteres de formato padrão corresponde a uma DateTimeFormatInfo propriedade cujo valor é uma cadeia de caracteres de formato de data e hora personalizada. Os especificadores individuais nessa cadeia de caracteres de formato personalizado, por sua vez, correspondem a outras DateTimeFormatInfo propriedades. A tabela lista apenas as propriedades para as DateTimeFormatInfo quais as cadeias de caracteres de formato padrão são aliases e não lista propriedades que podem ser acessadas por cadeias de caracteres de formato personalizado atribuídas a essas propriedades aliased. Além disso, a tabela lista apenas especificadores de formato personalizado que correspondem às DateTimeFormatInfo propriedades.

Especificador de formato Propriedades associadas
"d" (data curta; cadeia de caracteres de formato padrão) ShortDatePattern, para definir o formato geral da cadeia de caracteres de resultado.
"D" (data longa; cadeia de caracteres de formato padrão) LongDatePattern, para definir o formato geral da cadeia de caracteres de resultado.
"f" (data completa/tempo curto; cadeia de caracteres de formato padrão) LongDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.

ShortTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.
"F" (data completa/tempo longo; cadeia de caracteres de formato padrão) LongDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.

LongTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.
"g" (data geral/tempo curto; cadeia de caracteres de formato padrão) ShortDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.

ShortTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.
"G" (data geral/tempo longo; cadeia de caracteres de formato padrão) ShortDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.

LongTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.
"M", "m" (mês/dia; cadeia de caracteres de formato padrão) MonthDayPattern, para definir o formato geral da cadeia de caracteres de resultado.
"O", "o" (data/hora da viagem de ida e volta; cadeia de caracteres de formato padrão) Nenhum.
"R", "r" (RFC1123; cadeia de caracteres de formato padrão) RFC1123Pattern, para definir uma cadeia de caracteres de resultado em conformidade com o padrão RFC 1123. a propriedade é somente leitura.
"s" (data/hora classificada; cadeia de caracteres de formato padrão) SortableDateTimePattern, para definir uma cadeia de caracteres de resultado que esteja em conformidade com o padrão ISO 8601. a propriedade é somente leitura.
"t" (tempo curto; cadeia de caracteres de formato padrão) ShortTimePattern, para definir o formato geral da cadeia de caracteres de resultado.
"T" (longo tempo; cadeia de caracteres de formato padrão) LongTimePattern, para definir o formato geral da cadeia de caracteres de resultado.
"u" (data/hora classificação universal; cadeia de caracteres de formato padrão) UniversalSortableDateTimePattern, para definir uma cadeia de caracteres de resultado que esteja em conformidade com o padrão ISO 8601 para tempo universal coordenado. a propriedade é somente leitura.
"U" (data/hora completa universal; cadeia de caracteres de formato padrão) FullDateTimePattern, para definir o formato geral da cadeia de caracteres de resultado.
"Y", "y" (mês do ano; cadeia de caracteres de formato padrão) YearMonthPattern, para definir o formato geral da cadeia de caracteres de resultado.
"ddd" (especificador de formato personalizado) AbbreviatedDayNames, para incluir o nome abreviado do dia da semana na cadeia de caracteres de resultado.
"g", "gg" (especificador de formato personalizado) Chama o GetEraName método para inserir o nome da era na cadeia de caracteres de resultado.
"MMM" (especificador de formato personalizado) AbbreviatedMonthNames, para incluir o nome do mês abreviado na cadeia de caracteres de resultado.
"MMMM" (especificador de formato personalizado) MonthNames ou MonthGenitiveNames, para incluir o nome completo do mês na cadeia de caracteres de resultado.
"t" (especificador de formato personalizado) AMDesignator ou PMDesignator, para incluir o primeiro caractere do designador AM/PM na cadeia de caracteres de resultado.
"tt" (especificador de formato personalizado) AMDesignator ou PMDesignator, para incluir o designador AM/PM completo na cadeia de caracteres de resultado.
":" (especificador de formato personalizado) TimeSeparator, para incluir o separador de tempo na cadeia de caracteres de resultado.
"/" (especificador de formato personalizado) DateSeparator, para incluir o separador de data na cadeia de caracteres de resultado.

Modificando propriedades DateTimeFormatInfo

Você pode alterar a cadeia de caracteres de resultado produzida por cadeias de caracteres de formato de data e hora modificando as propriedades associadas de um objeto gravável DateTimeFormatInfo . Para determinar se um DateTimeFormatInfo objeto é gravável, use a IsReadOnly propriedade. Para personalizar um DateTimeFormatInfo objeto dessa forma:

  1. Crie uma cópia de leitura/gravação de um DateTimeFormatInfo objeto cujas convenções de formatação você deseja modificar. (Consulte a seção instanciando um objeto DateTimeFormatInfo .)

  2. Modifique a propriedade ou as propriedades usadas para produzir a cadeia de caracteres de resultado desejada. (Para obter informações sobre como os métodos de formatação usam DateTimeFormatInfo propriedades para definir cadeias de caracteres de resultado, consulte a seção anterior, as cadeias de caracteres de formato e as propriedades DateTimeFormatInfo.)

  3. Use o objeto personalizado DateTimeFormatInfo que você criou como o IFormatProvider argumento em chamadas para formatar métodos.

Há duas outras maneiras de alterar o formato de uma cadeia de caracteres de resultado:

  • Você pode usar a CultureAndRegionInfoBuilder classe para definir uma cultura personalizada (uma cultura que tem um nome exclusivo e que complementa culturas existentes) ou uma cultura de substituição (que é usada em vez de uma cultura específica). Você pode salvar e acessar essa cultura programaticamente como faria com qualquer CultureInfo objeto compatível com o .NET Framework.

  • Se a cadeia de caracteres de resultado não diferencia a cultura e não segue um formato predefinido, você pode usar uma cadeia de caracteres de formato de data e hora personalizada. Por exemplo, se você estiver serializando dados de data e hora no formato YYYYMMDDHHmmss, poderá gerar a cadeia de caracteres de resultado passando a cadeia de caracteres de formato personalizado para o DateTime.ToString(String) método e converter a cadeia de caracteres de resultado de volta em um DateTime valor chamando o DateTime.ParseExact método.

Alterando o padrão de data abreviada

O exemplo a seguir altera o formato de uma cadeia de caracteres de resultado produzida pela cadeia de caracteres de formato padrão "d" (data curta). Ele altera a propriedade associada ShortDatePattern para a cultura en-US ou inglês (Estados Unidos) de seu padrão de "M/d/yyy" para "yyy'-"MM"-"dd" e usa a cadeia de caracteres de formato padrão "d" para exibir a data antes e depois que a ShortDatePattern propriedade é alterada.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 8, 18);
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

      Console.WriteLine("Before modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}\n", dtfi.ShortDatePattern,
                                    dateValue.ToString("d", enUS));

      // Modify the short date pattern.
      dtfi.ShortDatePattern = "yyyy-MM-dd";
      Console.WriteLine("After modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern,
                                    dateValue.ToString("d", enUS));
   }
}
// The example displays the following output:
//       Before modifying DateTimeFormatInfo object:
//       M/d/yyyy: 8/18/2013
//
//       After modifying DateTimeFormatInfo object:
//       yyyy-MM-dd: 2013-08-18
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 18) 
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      
      Console.WriteLine("Before modifying DateTimeFormatInfo object: ")
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS))
      Console.WriteLine()
      
      ' Modify the short date pattern.
      dtfi.ShortDatePattern = "yyyy-MM-dd"
      Console.WriteLine("After modifying DateTimeFormatInfo object: ")
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS))
   End Sub
End Module
' The example displays the following output:
'       Before modifying DateTimeFormatInfo object:
'       M/d/yyyy: 8/18/2013
'       
'       After modifying DateTimeFormatInfo object:
'       yyyy-MM-dd: 2013-08-18

Alterando o caractere separador de data

O exemplo a seguir altera o caractere separador de data em um DateTimeFormatInfo objeto que representa as convenções de formatação da cultura fr-FR. O exemplo usa a cadeia de caracteres de formato padrão "g" para exibir a data antes e depois que a DateSeparator propriedade é alterada.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 08, 28);
      CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
      DateTimeFormatInfo dtfi = frFR.DateTimeFormat;

      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));

      // Modify the date separator.
      dtfi.DateSeparator = "-";
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
   }
}
// The example displays the following output:
//       Before modifying DateSeparator property: 28/08/2013 00:00
//       After modifying the DateSeparator property: 28-08-2013 00:00
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 28) 
      Dim frFR As CultureInfo = CultureInfo.CreateSpecificCulture("fr-FR")
      Dim dtfi As DateTimeFormatInfo = frFR.DateTimeFormat
      
      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR))
      
      ' Modify the date separator.
      dtfi.DateSeparator = "-"
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR))
   End Sub
End Module
' The example displays the following output:
'       Before modifying DateSeparator property: 28/08/2013 00:00
'       After modifying the DateSeparator property: 28-08-2013 00:00

Alterando abreviações do nome do dia e o padrão de data longa

Em alguns casos, o padrão de data longa, que normalmente exibe o nome completo do dia e do mês, juntamente com o número do dia do mês e do ano, pode ser muito longo. O exemplo a seguir reduz o padrão de data longa para que a cultura en-US retorne uma abreviação de nome de dia de um ou dois caracteres seguida pelo número do dia, pela abreviação do nome do mês e pelo ano. Ele faz isso atribuindo abreviações de nome de dia à AbbreviatedDayNames matriz e modificando a cadeia de caracteres de formato personalizado atribuída à LongDatePattern propriedade. Isso afeta as cadeias de caracteres de resultado retornadas pelas cadeias de caracteres de formato padrão "D" e "f".

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime value = new DateTime(2013, 7, 9);
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      String[] formats = { "D", "F", "f" };

      // Display date before modifying properties.
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));

      Console.WriteLine();

      // We don't want to change the FullDateTimePattern, so we need to save it.
      String originalFullDateTimePattern = dtfi.FullDateTimePattern;

      // Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
      dtfi.FullDateTimePattern = originalFullDateTimePattern;
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));
   }
}
// The example displays the following output:
//       D: Tuesday, July 9, 2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tuesday, July 9, 2013 12:00 AM
//
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tu 09-Jul-2013 12:00 AM
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As New Date(2013, 7, 9)
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim formats() As String = { "D", "F", "f" }

      ' Display date before modifying properties.
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' We don't want to change the FullDateTimePattern, so we need to save it.
      Dim originalFullDateTimePattern As String = dtfi.FullDateTimePattern
      
      ' Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = { "Su", "M", "Tu", "W", "Th", "F", "Sa" }
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy"
      dtfi.FullDateTimePattern = originalFullDateTimePattern
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' The example displays the following output:
'       D: Tuesday, July 9, 2013
'       F: Tuesday, July 9, 2013 12:00:00 AM
'       f: Tuesday, July 9, 2013 12:00 AM
'
'       D: Tu 09-Jul-2013
'       F: Tuesday, July 9, 2013 12:00:00 AM
'       f: Tu 09-Jul-2013 12:00 AM

Normalmente, a alteração na LongDatePattern propriedade também afeta a FullDateTimePattern propriedade, que, por sua vez, define a cadeia de caracteres de resultado retornada pela cadeia de caracteres de formato padrão "F". Para preservar o padrão de data e hora completo original, o exemplo reatribui a cadeia de caracteres de formato personalizado original atribuída à FullDateTimePattern propriedade após a modificação da LongDatePattern propriedade.

Alterando de um relógio de 12 horas para um relógio de 24 horas

Para muitas culturas no .NET Framework, a hora é expressa usando um relógio de 12 horas e um designador AM/PM. O exemplo a seguir define um ReplaceWith24HourClock método que substitui qualquer formato de hora que use um relógio de 12 horas por um formato que usa um relógio de 24 horas.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

      Console.WriteLine("Original Property Values:");
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
      Console.WriteLine();

      dtfi.LongTimePattern = ReplaceWith24HourClock(dtfi.LongTimePattern);
      dtfi.ShortTimePattern = ReplaceWith24HourClock(dtfi.ShortTimePattern);

      Console.WriteLine("Modififed Property Values:");
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
   }

   private static string ReplaceWith24HourClock(string fmt)
   {
      string pattern = @"^(?<openAMPM>\s*t+\s*)? " +
                       @"(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                       @"| \s*h+(?<nonHours>[^ht]+)\s*t+)";
      return Regex.Replace(fmt, pattern, "HH${nonHours}",
                           RegexOptions.IgnorePatternWhitespace);
   }
}
// The example displays the following output:
//       Original Property Values:
//       ShortTimePattern: h:mm tt
//       LongTimePattern: h:mm:ss tt
//       FullDateTimePattern: dddd, MMMM dd, yyyy h:mm:ss tt
//
//       Modififed Property Values:
//       ShortTimePattern: HH:mm
//       LongTimePattern: HH:mm:ss
//       FullDateTimePattern: dddd, MMMM dd, yyyy HH:mm:ss
Imports System.Globalization
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat

      Console.WriteLine("Original Property Values:")
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern)
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern)
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern)
      Console.WriteLine()
      
      dtfi.LongTimePattern = ReplaceWith24HourClock(dtfi.LongTimePattern)
      dtfi.ShortTimePattern = ReplaceWith24HourClock(dtfi.ShortTimePattern)
      
      Console.WriteLine("Modififed Property Values:")
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern)
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern)
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern)
   End Sub
   
   Private Function ReplaceWith24HourClock(fmt As String) As String
      Dim pattern As String = "^(?<openAMPM>\s*t+\s*)? " +
                              "(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                              "| \s*h+(?<nonHours>[^ht]+)\s*t+)"
      Return Regex.Replace(fmt, pattern, "HH${nonHours}", RegexOptions.IgnorePatternWhitespace)   
   End Function
End Module
' The example displays the following output:
'       Original Property Values:
'       ShortTimePattern: h:mm tt
'       LongTimePattern: h:mm:ss tt
'       FullDateTimePattern: dddd, MMMM dd, yyyy h:mm:ss tt
'       
'       Modififed Property Values:
'       ShortTimePattern: HH:mm
'       LongTimePattern: HH:mm:ss
'       FullDateTimePattern: dddd, MMMM dd, yyyy HH:mm:ss

O exemplo usa uma expressão regular para modificar a cadeia de caracteres de formato. O padrão de expressão @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) regular é definido da seguinte maneira:

Padrão Descrição
^ Começar a correspondência no início da cadeia de caracteres.
(?<openAMPM>\s*t+\s*)? Corresponde a zero ou uma ocorrência de zero ou mais caracteres de espaço em branco, seguido pela letra "t" uma ou mais vezes, seguida por zero ou mais caracteres de espaço em branco. Esse grupo de captura é nomeado openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Se o openAMPM grupo tiver uma correspondência, corresponda à letra "h" uma ou mais vezes, seguida por um ou mais caracteres que não são nem "h" nem "t". A correspondência termina no final da cadeia de caracteres. Todos os caracteres capturados após "h" são incluídos em um grupo de captura chamado nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Se o openAMPM grupo não tiver uma correspondência, corresponda à letra "h" uma ou mais vezes, seguida por um ou mais caracteres que não são nem "h" nem "t", seguidos por zero ou mais caracteres de espaço em branco. Por fim, corresponda a uma ou mais ocorrências da letra "t". Todos os caracteres capturados após "h" e antes dos espaços em branco e "t" são incluídos em um grupo de captura chamado nonHours.

O nonHours grupo de captura contém o minuto e, possivelmente, o segundo componente de uma cadeia de caracteres de formato de data e hora personalizada, juntamente com os símbolos do separador de hora. O padrão HH${nonHours} de substituição prepara a subcadeia de caracteres "HH" a esses elementos.

Exibindo e alterando a era uma data

O exemplo a seguir adiciona o especificador de formato personalizado "g" à LongDatePattern propriedade de um objeto que representa as convenções de formatação da cultura en-US. Essa adição afeta as três cadeias de caracteres de formato padrão a seguir:

  • A cadeia de caracteres de formato padrão "D" (data longa), que é mapeada diretamente para a LongDatePattern propriedade.

  • A cadeia de caracteres de formato padrão "f" (data completa/hora curta), que produz uma cadeia de caracteres de resultado que concatena as subcadeias de caracteres produzidas pelo e ShortTimePattern pelas LongDatePattern propriedades.

  • A cadeia de caracteres de formato padrão "F" (data completa/longa hora), que é mapeada diretamente para a FullDateTimePattern propriedade. Como não definimos explicitamente esse valor de propriedade, ele é gerado dinamicamente pela concatenação das propriedades e LongTimePattern da LongDatePattern propriedade.

O exemplo também mostra como alterar o nome da era para uma cultura cujo calendário tem uma única era. Nesse caso, a cultura en-US usa o calendário gregoriano, que é representado por um GregorianCalendar objeto. A GregorianCalendar classe dá suporte a uma única era, que ele nomeia como A.D. (Anno Domini). O exemplo altera o nome da era para C.E. (Era Comum) substituindo o especificador de formato personalizado "g" na cadeia de caracteres de formato atribuída à FullDateTimePattern propriedade por uma cadeia de caracteres literal. O uso de uma cadeia de caracteres literal é necessário, pois o nome da era normalmente é retornado pelo GetEraName método de dados privados nas tabelas de cultura fornecidas pelo .NET Framework ou pelo sistema operacional Windows.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 18, 13, 30, 0);
      String[] formats = { "D", "f", "F" };

      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      String originalLongDatePattern = dtfi.LongDatePattern;

      // Display the default form of three long date formats.
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

      Console.WriteLine();

      // Modify the long date pattern.
      dtfi.LongDatePattern = originalLongDatePattern + " g";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

      Console.WriteLine();

      // Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + @" 'C.E.'";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));
   }
}
// The example displays the following output:
//       Saturday, May 18, 2013
//       Saturday, May 18, 2013 1:30 PM
//       Saturday, May 18, 2013 1:30:00 PM
//
//       Saturday, May 18, 2013 A.D.
//       Saturday, May 18, 2013 A.D. 1:30 PM
//       Saturday, May 18, 2013 A.D. 1:30:00 PM
//
//       Saturday, May 18, 2013 C.E.
//       Saturday, May 18, 2013 C.E. 1:30 PM
//       Saturday, May 18, 2013 C.E. 1:30:00 PM
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 5, 18, 13, 30, 0)
      Dim formats() As String = { "D", "f", "F" }      
      
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim originalLongDatePattern As String = dtfi.LongDatePattern

      ' Display the default form of three long date formats.
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Modify the long date pattern.
      dtfi.LongDatePattern = originalLongDatePattern + " g"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + " 'C.E.'"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' The example displays the following output:
'       Saturday, May 18, 2013
'       Saturday, May 18, 2013 1:30 PM
'       Saturday, May 18, 2013 1:30:00 PM
'       
'       Saturday, May 18, 2013 A.D.
'       Saturday, May 18, 2013 A.D. 1:30 PM
'       Saturday, May 18, 2013 A.D. 1:30:00 PM
'       
'       Saturday, May 18, 2013 C.E.
'       Saturday, May 18, 2013 C.E. 1:30 PM
'       Saturday, May 18, 2013 C.E. 1:30:00 PM

Mantendo cadeias de caracteres de data e hora

A análise envolve a conversão da representação de cadeia de caracteres de uma data e hora em um valor ou DateTimeOffset dataDateTime. Ambos os tipos incluem os Parsemétodos , TryParse``ParseExacte TryParseExact para dar suporte a operações de análise. Os Parse métodos e TryParse os métodos convertem uma cadeia de caracteres que pode ter uma variedade de formatos, enquanto ParseExact TryParseExact que exigem que a cadeia de caracteres tenha um formato ou formato definido. Se a operação de análise falhar Parse e ParseExact lançar uma exceção, enquanto TryParse e TryParseExact retornar false.

Os métodos de análise usam implicitamente ou explicitamente um DateTimeStyles valor de enumeração para determinar quais elementos de estilo (como espaço à esquerda, à direita ou em branco interno) podem estar presentes na cadeia de caracteres a ser analisada e como interpretar a cadeia de caracteres analisada ou quaisquer elementos ausentes. Se você não fornecer um DateTimeStyles valor ao chamar o método ou TryParse o Parse método, o padrão será DateTimeStyles.AllowWhiteSpaces, que é um estilo composto que inclui o DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhitee DateTimeStyles.AllowInnerWhite sinalizadores. Para os métodos e TryParseExact métodosParseExact, o padrão éDateTimeStyles.None; a cadeia de caracteres de entrada deve corresponder precisamente a uma cadeia de caracteres de formato de data e hora personalizada específica.

Os métodos de análise também usam implicitamente ou explicitamente um DateTimeFormatInfo objeto que define os símbolos e padrões específicos que podem ocorrer na cadeia de caracteres a ser analisada. Se você não fornecer um DateTimeFormatInfo objeto, o DateTimeFormatInfo objeto para a cultura atual será usado por padrão. Para obter mais informações sobre a análise de cadeias de caracteres de data e hora, consulte os métodos de análise individuais, como DateTime.Parse, , DateTime.TryParsee DateTimeOffset.ParseExactDateTimeOffset.TryParseExact.

O exemplo a seguir ilustra a natureza sensível à cultura de analisar cadeias de caracteres de data e hora. Ele tenta analisar duas cadeias de caracteres de data usando as convenções das culturas en-US, en-GB, fr-FR e fi-FI. A data interpretada como 18/08/2014 na cultura en-US gera uma FormatException exceção nas outras três culturas porque 18 é interpretada como o número do mês. 1/2/2015 é analisado como o segundo dia do primeiro mês na cultura en-US, mas como o primeiro dia do segundo mês nas culturas restantes.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "08/18/2014", "01/02/2015" };
      string[] cultureNames = { "en-US", "en-GB", "fr-FR", "fi-FI" };

      foreach (var cultureName in cultureNames) {
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("Parsing strings using the {0} culture.",
                           culture.Name);
         foreach (var dateStr in dateStrings) {
            try {
               Console.WriteLine(String.Format(culture,
                                 "   '{0}' --> {1:D}", dateStr,
                                 DateTime.Parse(dateStr, culture)));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to parse '{0}'", dateStr);
            }
         }
      }
   }
}
// The example displays the following output:
//       Parsing strings using the en-US culture.
//          '08/18/2014' --> Monday, August 18, 2014
//          '01/02/2015' --> Friday, January 02, 2015
//       Parsing strings using the en-GB culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 01 February 2015
//       Parsing strings using the fr-FR culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> dimanche 1 février 2015
//       Parsing strings using the fi-FI culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 1. helmikuuta 2015
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "08/18/2014", "01/02/2015" }
      Dim cultureNames() As String = { "en-US", "en-GB", "fr-FR", "fi-FI" }
      
      For Each cultureName In cultureNames
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture.", 
                           culture.Name)
         For Each dateStr In dateStrings
            Try
               Console.WriteLine(String.Format(culture, 
                                 "   '{0}' --> {1:D}", dateStr, 
                                 DateTime.Parse(dateStr, culture)))
            Catch e As FormatException
               Console.WriteLine("   Unable to parse '{0}'", dateStr)
            End Try
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing strings using the en-US culture.
'          '08/18/2014' --> Monday, August 18, 2014
'          '01/02/2015' --> Friday, January 02, 2015
'       Parsing strings using the en-GB culture.
'          Unable to parse '08/18/2014'
'          '01/02/2015' --> 01 February 2015
'       Parsing strings using the fr-FR culture.
'          Unable to parse '08/18/2014'
'          '01/02/2015' --> dimanche 1 février 2015
'       Parsing strings using the fi-FI culture.
'          Unable to parse '08/18/2014'
'          '01/02/2015' --> 1. helmikuuta 2015

As cadeias de caracteres de data e hora normalmente são analisadas por dois motivos:

  • Para converter a entrada do usuário em um valor de data e hora.

  • Para ida e volta um valor de data e hora; ou seja, para desserializar um valor de data e hora que foi serializado anteriormente como uma cadeia de caracteres.

As seções a seguir discutem essas duas operações com mais detalhes.

Analisando cadeias de caracteres do usuário

Ao analisar as entradas de cadeias de caracteres de data e hora pelo usuário, você sempre deverá instanciar um DateTimeFormatInfo objeto que reflita as configurações culturais do usuário, incluindo as personalizações que o usuário possa ter feito. Caso contrário, o objeto de data e hora pode ter valores incorretos. Para obter informações sobre como instanciar um DateTimeFormatInfo objeto que reflete personalizações culturais do usuário, consulte a seção DateTimeFormatInfo e dados dinâmicos .

O exemplo a seguir ilustra a diferença entre uma operação de análise que reflete as configurações culturais do usuário e uma que não reflete. Nesse caso, a cultura padrão do sistema é en-US, mas o usuário usou Painel de Controle, Região e Idioma para alterar o padrão de data curta de seu padrão de "M/d/yyyyy" para "yy/MM/dd". Quando o usuário insere uma cadeia de caracteres que reflete as configurações do usuário e a cadeia de caracteres é analisada por um DateTimeFormatInfo objeto que também reflete as configurações do usuário (substituições), a operação de análise retorna um resultado correto. No entanto, quando a cadeia de caracteres é analisada por um DateTimeFormatInfo objeto que reflete as configurações culturais padrão nos EUA, o método de análise lança uma FormatException exceção porque interpreta 14 como o número do mês, não os dois últimos dígitos do ano.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string inputDate = "14/05/10";

      CultureInfo[] cultures = { CultureInfo.GetCultureInfo("en-US"),
                                 CultureInfo.CreateSpecificCulture("en-US") };

      foreach (var culture in cultures) {
         try {
            Console.WriteLine("{0} culture reflects user overrides: {1}",
                              culture.Name, culture.UseUserOverride);
            DateTime occasion = DateTime.Parse(inputDate, culture);
            Console.WriteLine("'{0}' --> {1}", inputDate,
                              occasion.ToString("D", CultureInfo.InvariantCulture));
         }
         catch (FormatException) {
            Console.WriteLine("Unable to parse '{0}'", inputDate);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       Unable to parse '14/05/10'
//
//       en-US culture reflects user overrides: True
//       '14/05/10' --> Saturday, 10 May 2014
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputDate As String = "14/05/10"
      
      Dim cultures() As CultureInfo = { CultureInfo.GetCultureInfo("en-US"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      
      For Each culture In cultures
         Try
            Console.WriteLine("{0} culture reflects user overrides: {1}", 
                              culture.Name, culture.UseUserOverride)
            Dim occasion As DateTime = DateTime.Parse(inputDate, culture)
            Console.WriteLine("'{0}' --> {1}", inputDate, 
                              occasion.ToString("D", CultureInfo.InvariantCulture))
         Catch e As FormatException
            Console.WriteLine("Unable to parse '{0}'", inputDate)                           
         End Try   
         Console.WriteLine()  
      Next
   End Sub
End Module
' The example displays the following output:
'       en-US culture reflects user overrides: False
'       Unable to parse '14/05/10'
'       
'       en-US culture reflects user overrides: True
'       '14/05/10' --> Saturday, 10 May 2014

Serializando e desserializando dados de data e hora

Espera-se que os dados de data e hora serializados sejam de ida e volta; ou seja, todos os valores serializados e desserializados devem ser idênticos. Se um valor de data e hora representar um único momento no tempo, o valor desserializado deverá representar o mesmo momento no tempo, independentemente da cultura ou fuso horário do sistema no qual foi restaurado. Para dados de data e hora de ida e volta com êxito, você deve usar as convenções da cultura invariável, que é retornada pela InvariantInfo propriedade, para gerar e analisar os dados. As operações de formatação e análise nunca devem refletir as convenções da cultura padrão. Se você usar configurações culturais padrão, a portabilidade dos dados será estritamente limitada; ele pode ser desserializado com êxito somente em um thread cujas configurações específicas de cultura são idênticas às do thread no qual ele foi serializado. Em alguns casos, isso significa que os dados não podem ser serializados e desserializados com êxito no mesmo sistema.

Se o componente de hora de um valor de data e hora for significativo, ele também deverá ser convertido em UTC e serializado usando a cadeia de caracteres de formato padrão "o" ou "r". Os dados de tempo podem ser restaurados chamando um método de análise e passando-os a cadeia de caracteres de formato apropriada junto com a cultura invariável como o provider argumento.

O exemplo a seguir ilustra o processo de arredondar um valor de data e hora. Ele serializa uma data e hora em um sistema que observa a hora do Pacífico dos EUA e cuja cultura atual está nos EUA.

using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\DateData.dat");
      // Define a date and time to serialize.
      DateTime originalDate = new DateTime(2014, 08, 18, 08, 16, 35);
      // Display information on the date and time.
      Console.WriteLine("Date to serialize: {0:F}", originalDate);
      Console.WriteLine("Current Culture:   {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}",
                        TimeZoneInfo.Local.DisplayName);
      // Convert the date value to UTC.
      DateTime utcDate = originalDate.ToUniversalTime();
      // Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo));
      sw.Close();
   }
}
// The example displays the following output:
//       Date to serialize: Monday, August 18, 2014 8:16:35 AM
//       Current Culture:   en-US
//       Time Zone:         (UTC-08:00) Pacific Time (US & Canada)
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\DateData.dat")
      ' Define a date and time to serialize.
      Dim originalDate As New Date(2014, 08, 18, 08, 16, 35)
      ' Display information on the date and time.
      Console.WriteLine("Date to serialize: {0:F}", originalDate)
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName)
      ' Convert the date value to UTC.
      Dim utcDate As Date = originalDate.ToUniversalTime()
      ' Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo))
      sw.Close()
   End Sub
End Module
' The example displays the following output:
'       Date to serialize: Monday, August 18, 2014 8:16:35 AM
'       Current Culture:   en-US
'       Time Zone:         (UTC-08:00) Pacific Time (US & Canada)

Desserializa os dados em um sistema no fuso horário de Bruxelas, Copenhague, Madri e Paris e cuja cultura atual é fr-FR. A data restaurada é nove horas mais tarde do que a data original, o que reflete o ajuste de fuso horário de oito horas atrás de UTC para uma hora à frente do UTC. A data original e a data restaurada representam o mesmo momento no tempo.

using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      // Open the file and retrieve the date string.
      StreamReader sr = new StreamReader(@".\DateData.dat");
      String dateValue = sr.ReadToEnd();

      // Parse the date.
      DateTime parsedDate = DateTime.ParseExact(dateValue, "o",
                            DateTimeFormatInfo.InvariantInfo);
      // Convert it to local time.
      DateTime restoredDate = parsedDate.ToLocalTime();
      // Display information on the date and time.
      Console.WriteLine("Deserialized date: {0:F}", restoredDate);
      Console.WriteLine("Current Culture:   {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}",
                        TimeZoneInfo.Local.DisplayName);
   }
}
// The example displays the following output:
//    Deserialized date: lundi 18 août 2014 17:16:35
//    Current Culture:   fr-FR
//    Time Zone:         (UTC+01:00) Brussels, Copenhagen, Madrid, Paris
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      ' Open the file and retrieve the date string.
      Dim sr As New StreamReader(".\DateData.dat")             
      Dim dateValue As String = sr.ReadToEnd()
      
      ' Parse the date.
      Dim parsedDate As Date = Date.ParseExact(dateValue, "o", 
                               DateTimeFormatInfo.InvariantInfo)
      ' Convert it to local time.                             
      Dim restoredDate As Date = parsedDate.ToLocalTime()
      ' Display information on the date and time.
      Console.WriteLine("Deserialized date: {0:F}", restoredDate)
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName)
   End Sub
End Module
' The example displays the following output:
'    Deserialized date: lundi 18 août 2014 17:16:35
'    Current Culture:   fr-FR
'    Time Zone:         (UTC+01:00) Brussels, Copenhagen, Madrid, Paris

Construtores

DateTimeFormatInfo()

Inicializa uma nova instância gravável da classe DateTimeFormatInfo que é independente da cultura (invariável).

Propriedades

AbbreviatedDayNames

Obtém ou define uma matriz unidimensional do tipo String que contém os nomes abreviados específicos da cultura dos dias da semana.

AbbreviatedMonthGenitiveNames

Obtém ou define uma matriz de cadeia de caracteres de nomes de meses abreviados associada ao objeto DateTimeFormatInfo atual.

AbbreviatedMonthNames

Obtém ou define uma matriz unidimensional de cadeia de caracteres que contém os nomes dos meses abreviados, específicos da cultura.

AMDesignator

Obtém ou define o designador de cadeia de caracteres de horas que são "ante meridiem" (antes do meio-dia).

Calendar

Obtém ou define o calendário a ser usado para a cultura atual.

CalendarWeekRule

Obtém ou define um valor que especifica qual regra é usada para determinar a primeira semana do ano.

CurrentInfo

Obtém o objeto DateTimeFormatInfo somente leitura que formata valores com base na cultura atual.

DateSeparator

Define a cadeia de caracteres que separa a os componentes de uma data, ou seja, o ano, mês e dia.

DayNames

Obtém ou define uma matriz unidimensional de cadeia de caracteres que contém os nomes dos dias da semana completos específicos da cultura.

FirstDayOfWeek

Obtém ou define o primeiro dia da semana.

FullDateTimePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor temporal longo e valor de data longo.

InvariantInfo

Obtém o objeto DateTimeFormatInfo padrão somente leitura que é independente da cultura (invariável).

IsReadOnly

Obtém um valor que indica se o objeto DateTimeFormatInfo é somente leitura.

LongDatePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de data longa.

LongTimePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor temporal extenso.

MonthDayPattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de mês e de dia.

MonthGenitiveNames

Obtém ou define uma matriz de cadeia de caracteres de nomes de meses associada ao objeto DateTimeFormatInfo atual.

MonthNames

Obtém ou define uma matriz unidimensional de tipo String que contém os nomes dos dias da semana completos específicos da cultura.

NativeCalendarName

Obtém o nome nativo do calendário associado ao objeto DateTimeFormatInfo atual.

PMDesignator

Obtém ou define o designador de cadeia de caracteres de horas que são "post meridiem" (depois do meio-dia).

RFC1123Pattern

Obtém a cadeia de caracteres de formato personalizado para um valor temporal baseado na especificação RFC (Request for Comments) 1123 da IETF (Internet Engineering Task Force).

ShortDatePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de data abreviada.

ShortestDayNames

Obtém ou define uma matriz de cadeia de caracteres dos nomes de dias abreviados únicos mais curtos associados ao objeto DateTimeFormatInfo atual.

ShortTimePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor temporal abreviado.

SortableDateTimePattern

Obtém a cadeia de caracteres de formato personalizado para um valor de data e hora classificável.

TimeSeparator

Obtém ou define a cadeia de caracteres que separa os componentes de tempo, ou seja, a hora, os minutos e os segundos.

UniversalSortableDateTimePattern

Obtém a cadeia de caracteres de formato personalizado para um valor de data e hora classificável e universal, conforme definido por ISO 8601.

YearMonthPattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de ano e mês.

Métodos

Clone()

Cria uma cópia superficial do DateTimeFormatInfo.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetAbbreviatedDayName(DayOfWeek)

Retorna o nome abreviado, específico da cultura, do dia da semana especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.

GetAbbreviatedEraName(Int32)

Retorna a cadeia de caracteres que contém o nome abreviado da era especificada, se houver uma abreviação.

GetAbbreviatedMonthName(Int32)

Retorna o nome abreviado da cultura específica do mês especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.

GetAllDateTimePatterns()

Retorna todos os padrões padrão nos quais os valores de data e hora podem ser formatados.

GetAllDateTimePatterns(Char)

Retorna todos os padrões nos quais os valores temporais podem ser formatados usando a cadeia de caracteres de formato padrão especificada.

GetDayName(DayOfWeek)

Retorna o nome completo, específico da cultura, do dia da semana especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.

GetEra(String)

Retorna o inteiro que representa a era especificada.

GetEraName(Int32)

Retorna a cadeia de caracteres que contém o nome da era especificado.

GetFormat(Type)

Retorna um objeto do tipo especificado que fornece um serviço de formatação de data e hora.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetInstance(IFormatProvider)

Retorna o objeto DateTimeFormatInfo associado ao IFormatProvider especificado.

GetMonthName(Int32)

Retorna o nome completo da cultura específica do mês especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.

GetShortestDayName(DayOfWeek)

Obtém o nome abreviado do dia mais curto de um dia especificado da semana associado ao objeto DateTimeFormatInfo atual.

GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ReadOnly(DateTimeFormatInfo)

Retorna um wrapper DateTimeFormatInfo de somente leitura.

SetAllDateTimePatterns(String[], Char)

Define as cadeias de caracteres de formato de data e hora personalizado que correspondem a uma cadeia de caracteres de formato padrão especificada.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Implantações explícitas de interface

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popula um SerializationInfo com os dados necessários para serializar o objeto de destino.

Aplica-se a

Confira também