DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo Class

Definição

Fornece informações específicas da cultura sobre o formato dos valores de data e hora.Provides culture-specific information about the format of date and time values.

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

Exemplos

O exemplo a seguir usa a reflexão para obter as propriedades DateTimeFormatInfo do objeto para a cultura em inglês (Estados Unidos).The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. 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.It displays the value of those properties that contain custom format strings and uses those strings to display formatted dates.

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 de cultura para formatação ou análise de valores de data e hora, como o seguinte:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Os padrões usados para formatar valores de data.The patterns used to format date values.

  • Os padrões usados para formatar valores de tempo.The patterns used to format time values.

  • Os nomes dos dias da semana.The names of the days of the week.

  • Os nomes dos meses do ano.The names of the months of the year.

  • ÀsThe A.M. e P.M.and P.M. designadores usados em valores de tempo.designators used in time values.

  • O calendário no qual as datas são expressas.The calendar in which dates are expressed.

Nesta seção:In this section:

Criando uma instância de um objeto DateTimeFormatInfoInstantiating a DateTimeFormatInfo object

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.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. Esta seção discute como criar uma instância de cada tipo DateTimeFormatInfo de objeto.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Criando uma instância de um objeto DateTimeFormatInfo para a cultura invariávelInstantiating a DateTimeFormatInfo object for the invariant culture

A cultura invariável representa uma cultura insensível.The invariant culture represents a culture that is culture-insensitive. Ele se baseia no idioma inglês, mas não em nenhum país/região específico de língua inglesa.It is based on the English language, but not on any specific English-speaking country/region. Embora os dados de culturas específicas possam ser dinâmicos e possam mudar para refletir novas convenções culturais ou preferências de usuário, os dados da cultura invariável não são alterados.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Você pode criar uma DateTimeFormatInfo instância de um objeto que representa as convenções de formatação da cultura invariável das seguintes maneiras:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

O exemplo a seguir usa cada um desses métodos para criar DateTimeFormatInfo uma instância de um objeto que representa a cultura invariável.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. Em seguida, ele indica se o objeto é somente leitura.It then indicates whether the object is read-only.

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íficaInstantiating a DateTimeFormatInfo object for a specific culture

Uma cultura específica representa uma linguagem que é falada em um país/região específico.A specific culture represents a language that is spoken in a particular country/region. Por exemplo, en-US é uma cultura específica que representa o idioma Inglês falado na Estados Unidos, e en-CA é uma cultura específica que representa o idioma Inglês falado no Canadá.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Você pode criar uma DateTimeFormatInfo instância de um objeto que representa as convenções de formatação de uma cultura específica das seguintes maneiras:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

O exemplo a seguir ilustra cada uma dessas maneiras de criar DateTimeFormatInfo uma instância de um objeto e indica se o objeto resultante é somente leitura.The following example illustrates each of these ways to instantiate a DateTimeFormatInfo object and indicates whether the resulting object is read-only.

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 neutraInstantiating a DateTimeFormatInfo object for a neutral culture

Uma cultura neutra representa uma cultura ou linguagem que é independente de um país/região; Normalmente, é o pai de uma ou mais culturas específicas.A neutral culture represents a culture or language that is independent of a country/region; it is typically the parent of one or more specific cultures. Por exemplo, fr é uma cultura neutra para o idioma francês e o pai da cultura fr-FR.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. Você pode criar uma DateTimeFormatInfo instância de um objeto que representa as convenções de formatação de uma cultura neutra da mesma maneira que DateTimeFormatInfo cria um objeto que representa as convenções de formatação de uma cultura específica.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a neutral culture in the same ways that you create a DateTimeFormatInfo object that represents the formatting conventions of a specific culture. Além disso, você pode recuperar um objeto DateTimeFormatInfo de cultura neutra recuperando uma cultura neutra de uma propriedade de CultureInfo.Parent cultura específica e recuperando o DateTimeFormatInfo objeto retornado por sua CultureInfo.DateTimeFormat propriedade.In addition, you can retrieve a neutral culture's DateTimeFormatInfo object by retrieving a neutral culture from a specific culture's CultureInfo.Parent property and retrieving the DateTimeFormatInfo object returned by its CultureInfo.DateTimeFormat property. A menos que a cultura pai represente a cultura invariável, o objeto retornado DateTimeFormatInfo é leitura/gravação.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. O exemplo a seguir ilustra essas maneiras de instanciar DateTimeFormatInfo um objeto que representa uma cultura neutra.The following example illustrates these ways of instantiating a DateTimeFormatInfo object that represents a neutral culture.

 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.NET Framework 3.5, tentar recuperar um DateTimeFormatInfo objeto que reflita as convenções de formatação de uma cultura neutra gera uma NotSupportedException exceção.In the .NET Framework versions 1.0 through .NET Framework 3,5.NET Framework 3.5, trying to retrieve a DateTimeFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

No entanto, uma cultura neutra não tem informações de formatação específicas da cultura, pois ela é independente de um país/região específico.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. Em vez de preencher DateTimeFormatInfo o objeto com valores genéricos, o .NET Framework retorna DateTimeFormatInfo um objeto que reflete as convenções de formatação de uma cultura específica que é um filho da cultura neutra.Instead of populating the DateTimeFormatInfo object with generic values, the .NET Framework returns a DateTimeFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Por exemplo, o DateTimeFormatInfo objeto para a cultura neutra de neutral reflete as convenções de formatação da cultura en-US, e DateTimeFormatInfo o objeto da cultura fr reflete as convenções de formatação da cultura fr-fr.For example, the DateTimeFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the DateTimeFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Você pode usar um código como o seguinte para determinar quais convenções de formatação de cultura específica representam uma cultura neutra.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. O exemplo usa a reflexão para comparar DateTimeFormatInfo as propriedades de uma cultura neutra com as propriedades de uma cultura filho específica.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Ele considera que dois calendários serão equivalentes se forem o mesmo tipo de calendário e, para calendários gregorianos, GregorianCalendar.CalendarType se suas propriedades tiverem valores idênticos.It considers two calendars to be equivalent if they are the same calendar type and, for Gregorian calendars, if their GregorianCalendar.CalendarType properties have identical values.

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 atualInstantiating a DateTimeFormatInfo object for the current culture

Você pode criar uma DateTimeFormatInfo instância de um objeto que representa as convenções de formatação da cultura atual das seguintes maneiras:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

O exemplo a seguir usa cada um desses métodos para criar DateTimeFormatInfo uma instância de um objeto que representa as convenções de formatação da cultura atual.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. Em seguida, ele indica se o objeto é somente leitura.It then indicates whether the object is read-only.

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 DateTimeFormatInfo gravável que representa as convenções da cultura do thread atual de uma das seguintes maneiras:You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

O exemplo a seguir ilustra cada forma de instanciar um objeto de DateTimeFormatInfo leitura/gravação e exibe o valor IsReadOnly de sua propriedade.The following example illustrates each way of instantiating a read/write DateTimeFormatInfo object and displays the value of its IsReadOnly property.

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

No Windows, o usuário pode substituir alguns dos valores DateTimeFormatInfo de propriedade usados na formatação e na análise de operações por meio do aplicativo região e idioma no painel de controle.In Windows, the user can override some of the DateTimeFormatInfo property values used in formatting and parsing operations through the Region and Language application in Control Panel. Por exemplo, um usuário cuja cultura é inglês (Estados Unidos) pode optar por exibir valores de tempo longos 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).For example, a user whose culture is English (United States) might choose to display long time values using a 24-hour clock (in the format HH:mm:ss) instead of the default 12-hour clock (in the format h:mm:ss tt). Os DateTimeFormatInfo objetos recuperados das maneiras discutidas anteriormente refletem essas substituições do usuário.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Se isso for indesejável, você poderá criar NumberFormatInfo um objeto que não reflita substituições de usuário (e também é de leitura/gravação em vez de somente leitura) CultureInfo.CultureInfo(String, Boolean) chamando o construtor e fornecendo um valor false de para useUserOverride o argumento.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and is also read/write instead of read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. O exemplo a seguir ilustra isso para um sistema cuja cultura atual é inglês (Estados Unidos) e cujo padrão de tempo longo foi alterado do padrão h:mm: SS TT para HH: mm: SS.The following example illustrates this for a system whose current culture is English (United States) and whose long time pattern has been changed from the default of h:mm:ss tt to 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âmicosDateTimeFormatInfo and dynamic data

Os dados específicos de cultura para formatação de valores de data e hora fornecidos DateTimeFormatInfo pela classe são dinâmicos, assim como os dados culturais CultureInfo fornecidos pela classe.The culture-specific data for formatting date and time values provided by the DateTimeFormatInfo class is dynamic, just like cultural data provided by the CultureInfo class. Você não deve fazer suposições sobre a estabilidade de valores para DateTimeFormatInfo objetos associados a objetos específicos. CultureInfoYou should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Somente os dados fornecidos pela cultura invariável e seu objeto DateTimeFormatInfo associado são estáveis.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. Outros dados podem ser alterados entre sessões do aplicativo ou mesmo enquanto seu aplicativo está em execução.Other data can change between application sessions or even while your application is running. Há quatro fontes de alteração principais:There are four major sources of change:

  • Atualizações do sistema.System updates. As preferências culturais, como o calendário preferencial ou os formatos de data e hora personalizados, mudam com o passar do tempo.Cultural preferences such as the preferred calendar or customary date and time formats change over time. Quando isso acontece, o Windows Update inclui alterações DateTimeFormatInfo no valor da propriedade para uma cultura específica.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Culturas de substituição.Replacement cultures. A CultureAndRegionInfoBuilder classe pode ser usada para substituir os dados de uma cultura existente.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Alterações em cascata para valores de propriedade.Cascading changes to property values. Várias propriedades relacionadas à cultura podem ser alteradas em tempo de execução, o que, por sua DateTimeFormatInfo vez, faz com que os dados sejam alterados.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Por exemplo, a cultura atual pode ser alterada programaticamente ou por meio de ação do usuário.For example, the current culture can be changed either programmatically or through user action. Quando isso acontece, o DateTimeFormatInfo objeto retornado CurrentInfo pela propriedade é alterado para um objeto associado à cultura atual.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. Da mesma forma, o calendário de uma cultura pode ser alterado, o que pode DateTimeFormatInfo resultar em alterações em vários valores de propriedade.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Preferências do usuário.User preferences. Os usuários do seu 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.Users of your application might choose to override some of the values associated with the current system culture through the regional and language options in Control Panel. Por exemplo, os usuários podem optar por exibir a data em um formato diferente.For example, users might choose to display the date in a different format. Se a CultureInfo.UseUserOverride propriedade for definida como true DateTimeFormatInfo , as propriedades do objeto também serão recuperadas das configurações do usuário.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. 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 OptionalCalendars pela propriedade), os resultados dos métodos e dos valores das propriedades são indefinidos.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars indicated by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Para minimizar a possibilidade de dados inconsistentes, todas as propriedades substituíveis pelo DateTimeFormatInfo usuário de um objeto são inicializadas quando o objeto é criado.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. Ainda há uma possibilidade de inconsistência, porque nenhuma criação de objeto nem o processo de substituição do usuário é atômico, e os valores relevantes podem ser alterados durante a criação do objeto.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic and the relevant values can change during object creation. No entanto, essa situação deve ser extremamente rara.However, this situation should be extremely rare.

Você pode controlar se as substituições do usuário DateTimeFormatInfo são refletidas em objetos que representam a mesma cultura que a cultura do sistema.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. A tabela a seguir lista as maneiras pelas quais DateTimeFormatInfo um objeto pode ser recuperado e indica se o objeto resultante reflete as substituições do usuário.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Fonte do objeto CultureInfo e DateTimeFormatInfoSource of CultureInfo and DateTimeFormatInfo object Reflete as substituições do usuárioReflects user overrides
Propriedade CultureInfo.CurrentCulture.DateTimeFormatCultureInfo.CurrentCulture.DateTimeFormat property SimYes
Propriedade DateTimeFormatInfo.CurrentInfoDateTimeFormatInfo.CurrentInfo property SimYes
Método CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method SimYes
Método CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NãoNo
Construtor CultureInfo.CultureInfo(String)CultureInfo.CultureInfo(String) constructor SimYes
Construtor CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Depende do valor do useUserOverride parâmetroDepends on value of useUserOverride parameter

A menos que haja um motivo convincente para fazer o contrário, você deve respeitar as substituições do usuário DateTimeFormatInfo ao usar o objeto em aplicativos cliente para formatar e analisar a entrada do usuário ou para exibir dados.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the DateTimeFormatInfo object in client applications to format and parse user input or to display data. Para aplicativos de servidor ou aplicativos autônomos, você não deve.For server applications or unattended applications, you should not. No entanto, se você estiver DateTimeFormatInfo usando o objeto de forma explícita ou implícita para manter os dados de data e hora no formulário de cadeia de DateTimeFormatInfo caracteres, deverá usar um objeto que reflita as convenções de formatação da cultura invariável ou deve especificar um Cadeia de caracteres de formato de data e hora personalizado que você usa independentemente da cultura.However, if you are using the DateTimeFormatInfo object either explicitly or implicitly to persist date and time data in string form, you should either use a DateTimeFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom date and time format string that you use regardless of culture.

Formatando datas e horasFormatting dates and times

Um DateTimeFormatInfo objeto é usado implicitamente ou explicitamente em todas as operações de formatação de data e hora.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Isso inclui chamadas para os seguintes métodos:These include calls to the following methods:

Todas as operações de formatação de data e hora fazem IFormatProvider uso de uma implementação.All date and time formatting operations make use of an IFormatProvider implementation. A IFormatProvider interface inclui um único método, IFormatProvider.GetFormat(Type).The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Esse método de retorno de chamada Type é passado a um objeto que representa o tipo necessário para fornecer informações de formatação.This callback method is passed a Type object that represents the type needed to provide formatting information. O método retorna uma instância desse tipo ou null se ele não puder fornecer uma instância do tipo.The method returns either an instance of that type or null if it cannot provide an instance of the type. O .NET Framework inclui duas IFormatProvider implementações para formatar datas e horas:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Se uma IFormatProvider implementação não for fornecida explicitamente a um método de formatação, CultureInfo o objeto retornado pela CultureInfo.CurrentCulture propriedade que representa a cultura de thread atual será usado.If an IFormatProvider implementation is not provided to a formatting method explicitly, the CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

O exemplo a seguir ilustra a relação entre IFormatProvider a interface e DateTimeFormatInfo a classe em operações de formatação.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Ele define uma implementação IFormatProvider personalizada cujo GetFormat método exibe o tipo do objeto solicitado pela operação de formatação.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. Se ele estiver solicitando DateTimeFormatInfo um objeto, o método fornecerá o DateTimeFormatInfo objeto para a cultura de thread atual.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Como a saída do exemplo mostra Decimal.ToString(IFormatProvider) , o 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 um ICustomFormatter implementação.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a DateTimeFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

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, 12, 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 DateTimeFormatInfoFormat strings and DateTimeFormatInfo properties

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:The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

As cadeias de caracteres de formato padrão de data e hora, como "d", "d", "f" e "f", são aliases que correspondem DateTimeFormatInfo às propriedades específicas de padrão de formato.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. A maioria das cadeias de caracteres de formato de data e hora personalizadas estão relacionadas a cadeias de caracteres ou subcadeias que uma operação de formatação insere no fluxo de resultados.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. A tabela a seguir lista os especificadores padrão e personalizado de formato de data e hora DateTimeFormatInfo e suas propriedades associadas.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Para obter detalhes sobre como usar esses especificadores de formato, consulte cadeias de caracteres de formato padrão de data e hora e cadeias de caracteres de formato de data e hora personalizadas.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Observe que cada cadeia de caracteres de formato padrão DateTimeFormatInfo corresponde a uma propriedade cujo valor é uma cadeia de caracteres de formato de data e hora personalizada.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Os especificadores individuais nessa cadeia de caracteres de formato personalizado, por sua DateTimeFormatInfo vez, correspondem a outras propriedades.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. A tabela lista apenas as DateTimeFormatInfo Propriedades para as quais as cadeias de caracteres de formato padrão são aliases e não lista as propriedades que podem ser acessadas por cadeias de caracteres de formato personalizado atribuídas a essas propriedades com alias.The table lists only the DateTimeFormatInfo properties for which the standard format strings are aliases, and does not list properties that may be accessed by custom format strings assigned to those aliased properties. Além disso, a tabela lista somente especificadores de formato personalizados que correspondem DateTimeFormatInfo às propriedades.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

Especificador de formatoFormat specifier Propriedades associadasAssociated properties
"d" (data abreviada; cadeia de caracteres de formato padrão)"d" (short date; standard format string) ShortDatePattern, para definir o formato geral da cadeia de caracteres de resultado.ShortDatePattern, to define the overall format of the result string.
"D" (data por extenso; cadeia de caracteres de formato padrão)"D" (long date; standard format string) LongDatePattern, para definir o formato geral da cadeia de caracteres de resultado.LongDatePattern, to define the overall format of the result string.
"f" (data/hora completa; cadeia de caracteres de formato padrão)"f" (full date / short time; standard format string) LongDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.LongDatePattern, to define the format of the date component of the result string.

ShortTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.ShortTimePattern, to define the format of the time component of the result string.
"F" (data/hora completa; cadeia de caracteres de formato padrão)"F" (full date / long time; standard format string) LongDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.LongDatePattern, to define the format of the date component of the result string.

LongTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.LongTimePattern, to define the format of the time component of the result string.
"g" (data geral/hora abreviada; cadeia de caracteres de formato padrão)"g" (general date / short time; standard format string) ShortDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.ShortTimePattern, to define the format of the time component of the result string.
"G" (data geral/hora completa; cadeia de caracteres de formato padrão)"G" (general date / long time; standard format string) ShortDatePattern, para definir o formato do componente de data da cadeia de caracteres de resultado.ShortDatePattern, to define the format of the date component of the result string.

LongTimePattern, para definir o formato do componente de tempo da cadeia de caracteres de resultado.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (mês/dia; cadeia de caracteres de formato padrão)"M", "m" (month/day; standard format string) MonthDayPattern, para definir o formato geral da cadeia de caracteres de resultado.MonthDayPattern, to define the overall format of the result string.
"O", "o" (data/hora de ida e volta; cadeia de caracteres de formato padrão)"O", "o" (round-trip date/time; standard format string) nenhuma.None.
"R", "r" (RFC1123; cadeia de caracteres de formato padrão)"R", "r" (RFC1123; standard format string) RFC1123Pattern, para definir uma cadeia de caracteres de resultado que esteja de acordo com o padrão RFC 1123.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. A propriedade é somente leitura.The property is read-only.
"s" (data/hora classificável; cadeia de caracteres de formato padrão)"s" (sortable date/time; standard format string) SortableDateTimePattern, para definir uma cadeia de caracteres de resultado que esteja de acordo com o padrão ISO 8601.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. A propriedade é somente leitura.The property is read-only.
"t" (hora abreviada; cadeia de caracteres de formato padrão)"t" (short time; standard format string) ShortTimePattern, para definir o formato geral da cadeia de caracteres de resultado.ShortTimePattern, to define the overall format of the result string.
"T" (longo tempo; cadeia de caracteres de formato padrão)"T" (long time; standard format string) LongTimePattern, para definir o formato geral da cadeia de caracteres de resultado.LongTimePattern, to define the overall format of the result string.
"u" (data/hora universal classificável; cadeia de caracteres de formato padrão)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, para definir uma cadeia de caracteres de resultado que esteja de acordo com o padrão ISO 8601 para tempo universal coordenado.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. A propriedade é somente leitura.The property is read-only.
"U" (data/hora universal completa; cadeia de caracteres de formato padrão)"U" (universal full date/time; standard format string) FullDateTimePattern, para definir o formato geral da cadeia de caracteres de resultado.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (ano mês; cadeia de caracteres de formato padrão)"Y", "y" (year month; standard format string) YearMonthPattern, para definir o formato geral da cadeia de caracteres de resultado.YearMonthPattern, to define the overall format of the result string.
"ddd" (especificador de formato personalizado)"ddd" (custom format specifier) AbbreviatedDayNames, para incluir o nome abreviado do dia da semana na cadeia de caracteres de resultado.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "GG" (especificador de formato personalizado)"g", "gg" (custom format specifier) Chama o GetEraName método para inserir o nome da era na cadeia de caracteres de resultado.Calls the GetEraName method to insert the era name in the result string.
"MMM" (especificador de formato personalizado)"MMM" (custom format specifier) AbbreviatedMonthNames, para incluir o nome abreviado do mês na cadeia de caracteres de resultado.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (especificador de formato personalizado)"MMMM" (custom format specifier) MonthNamesou MonthGenitiveNames, para incluir o nome completo do mês na cadeia de caracteres de resultado.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (especificador de formato personalizado)"t" (custom format specifier) AMDesignatorou PMDesignator, para incluir o primeiro caractere do designador AM/PM na cadeia de caracteres de resultado.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"tt" (especificador de formato personalizado)"tt" (custom format specifier) AMDesignatorou PMDesignator, para incluir o designador AM/PM completo na cadeia de caracteres de resultado.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
":" (especificador de formato personalizado)":" (custom format specifier) TimeSeparator, para incluir o separador de tempo na cadeia de caracteres de resultado.TimeSeparator, to include the time separator in the result string.
"/" (especificador de formato personalizado)"/" (custom format specifier) DateSeparator, para incluir o separador de data na cadeia de caracteres de resultado.DateSeparator, to include the date separator in the result string.

Modificando propriedades DateTimeFormatInfoModifying DateTimeFormatInfo properties

Você pode alterar a cadeia de caracteres de resultado produzida pelas cadeias de formato de data e hora modificando DateTimeFormatInfo as propriedades associadas de um objeto gravável.You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. Para determinar se um DateTimeFormatInfo objeto é gravável, use a IsReadOnly propriedade.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. Para personalizar um DateTimeFormatInfo objeto desta maneira:To customize a DateTimeFormatInfo object in this way:

  1. Crie uma cópia de leitura/gravação de DateTimeFormatInfo um objeto cujas convenções de formatação você deseja modificar.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Consulte a seção instanciando um objeto DateTimeFormatInfo .)(See the Instantiating a DateTimeFormatInfo object section.)

  2. Modifique a propriedade ou as propriedades que são usadas para produzir a cadeia de caracteres de resultado desejada.Modify the property or properties that are used to produce the desired result string. (Para obter informações sobre como os métodos DateTimeFormatInfo de formatação usam propriedades para definir cadeias de caracteres de resultado, consulte a seção anterior, Formatar cadeias de caracteres e propriedades DateTimeFormatInfo.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Use o objeto DateTimeFormatInfo personalizado que você criou IFormatProvider como argumento em chamadas para métodos de formatação.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Há duas outras maneiras de alterar o formato de uma cadeia de caracteres de resultado:There are two other ways to change the format of a result string:

  • Você pode usar a CultureAndRegionInfoBuilder classe para definir uma cultura personalizada (uma cultura que tem um nome exclusivo e que complementa as culturas existentes) ou uma cultura substituta (uma que é usada em vez de uma cultura específica).You can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture). Você pode salvar e acessar essa cultura programaticamente, como CultureInfo faria com qualquer objeto com suporte na .NET Framework.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Se a cadeia de caracteres de resultado não for sensível à cultura e não seguir um formato predefinido, você poderá usar uma cadeia de caracteres de formato de data e hora personalizada.If the result string is not culture-sensitive and doesn't follow a predefined format, you can use a custom date and time format string. Por exemplo, se você estiver serializando dados de data e hora no formato AAAAMMDDHHMMSS, poderá gerar a cadeia de caracteres de resultado passando a cadeia de caracteres DateTime.ToString(String) de formato personalizado para o método e poderá converter a cadeia de DateTime caracteres de resultado para um valor chamando o DateTime.ParseExact método.For example, if you are serializing date and time data in the format YYYYMMDDHHmmss, you can generate the result string by passing the custom format string to the DateTime.ToString(String) method, and you can convert the result string back to a DateTime value by calling the DateTime.ParseExact method.

Alterando o padrão de data abreviadaChanging the short date pattern

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 abreviada).The following example changes the format of a result string produced by the "d" (short date) standard format string. Ele altera a propriedade ShortDatePattern associada para a cultura en-US ou inglês (Estados Unidos) do seu padrão de "M/d/aaaa" para "aaaa"-"mm"-"dd" e usa a cadeia de caracteres de formato padrão "d" para exibir a data antes e ShortDatePattern depois da propriedade ser Changed.It changes the associated ShortDatePattern property for the en-US or English (United States) culture from its default of "M/d/yyyy" to "yyyy'-"MM"-"dd" and uses the "d" standard format string to display the date both before and after the ShortDatePattern property is changed.

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 dataChanging the date separator character

O exemplo a seguir altera o caractere de separador de data em um DateTimeFormatInfo objeto que representa as convenções de formatação da cultura fr-fr.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. O exemplo usa a cadeia de caracteres de formato padrão "g" para exibir a data antes e DateSeparator depois que a propriedade é alterada.The example uses the "g" standard format string to display the date both before and after the DateSeparator property is changed.

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: 18/08/2013 00:00
//       After modifying the DateSeparator property: 18-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 longaChanging day name abbreviations and the long date pattern

Em alguns casos, o padrão de data por extenso, que normalmente exibe o nome completo do dia e do mês junto com o número do dia do mês e do ano, pode ser muito longo.In some cases, the long date pattern, which typically displays the full day and month name along with the number of the day of the month and the year, may be too long. O exemplo a seguir reduz o padrão de data por extenso para a cultura en-US para retornar uma abreviação de nome de dia de um caractere ou de dois caracteres, seguida do número do dia, a abreviação do nome do mês e o ano.The following example shortens the long date pattern for the en-US culture to return a one-character or two-character day name abbreviation followed by the day number, the month name abbreviation, and the year. Ele faz isso atribuindo abreviações de nome de AbbreviatedDayNames dia mais curto à matriz e modificando a cadeia de caracteres de formato personalizado atribuída LongDatePattern à propriedade.It does this by assigning shorter day name abbreviations to the AbbreviatedDayNames array, and by modifying the custom format string assigned to the LongDatePattern property. Isso afeta as cadeias de caracteres de resultado retornadas pelas cadeias de caracteres de formato padrão "D" e "f".This affects the result strings returned by the "D" and "f" standard format strings.

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 09, 2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tuesday, July 09, 2013 12:00 AM
//       
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 09, 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 09, 2013
'       F: Tuesday, July 09, 2013 12:00:00 AM
'       f: Tuesday, July 09, 2013 12:00 AM
'       
'       D: Tu 09-Jul-2013
'       F: Tuesday, July 09, 2013 12:00:00 AM
'       f: Tu 09-Jul-2013 12:00 AM

Normalmente, a alteração LongDatePattern na 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".Ordinarily, the change to the LongDatePattern property also affects the FullDateTimePattern property, which in turn defines the result string returned by the "F" standard format string. Para preservar o padrão completo original de data e hora, o exemplo reatribui a cadeia de caracteres de formato personalizado original FullDateTimePattern atribuída à propriedade LongDatePattern depois que a propriedade é modificada.To preserve the original full date and time pattern, the example reassigns the original custom format string assigned to the FullDateTimePattern property after the LongDatePattern property is modified.

Alterando de um relógio de 12 horas para um relógio de 24 horasChanging from a 12-hour clock to a 24-hour clock

Para muitas culturas na .NET Framework, o tempo é expresso usando um relógio de 12 horas e um designador AM/PM.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. O exemplo a seguir define ReplaceWith24HourClock um método que substitui qualquer formato de hora que usa um relógio de 12 horas com um formato que usa um relógio de 24 horas.The following example defines a ReplaceWith24HourClock method that replaces any time format that uses a 12-hour clock with a format that uses a 24-hour clock.

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.The example uses a regular expression to modify the format string. O padrão @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) de expressão regular é definido da seguinte maneira:The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

PadrãoPattern DescriçãoDescription
^ Começar a correspondência no início da cadeia de caracteres.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Corresponder zero ou uma ocorrência de zero ou mais caracteres de espaço em branco, seguido da letra "t" uma ou mais vezes, seguido de zero ou mais caracteres de espaço em branco.Match zero or one occurrence of zero or more white-space characters, followed by the letter "t" one or more times, followed by zero or more white-space characters. Esse grupo de captura é openAMPMnomeado.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Se o openAMPM grupo tiver uma correspondência, corresponda à letra "h" uma ou mais vezes, seguido por um ou mais caracteres que não são "h" nem "t".If the openAMPM group has a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t". A correspondência termina no final da cadeia de caracteres.The match ends at the end of the string. Todos os caracteres capturados após "h" são incluídos em um grupo nonHoursde captura chamado.All characters captured after "h" are included in a capturing group named 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, seguido por um ou mais caracteres que não são "h" nem "t", seguidos por zero ou mais caracteres de espaço em branco.If the openAMPM group does not have a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t", followed by zero or more white-space characters. Por fim, corresponda a uma ou mais ocorrências da letra "t".Finally, match one or more occurrences of the letter "t". Todos os caracteres capturados após "h" e antes dos espaços em branco e "t" são incluídos em um grupo nonHoursde captura chamado.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named 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 personalizado, juntamente com qualquer símbolo de separador de tempo.The nonHours capturing group contains the minute and possibly the second component of a custom date and time format string, along with any time separator symbols. O padrão HH${nonHours} de substituição precede a subcadeia de caracteres "HH" para esses elementos.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Exibindo e alterando a era uma dataDisplaying and changing the era in a date

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.The following example adds the "g" custom format specifier to the LongDatePattern property of an object that represents the formatting conventions of the en-US culture. Essa adição afeta as três seguintes cadeias de caracteres de formato padrão:This addition affects the following three standard format strings:

  • A cadeia de caracteres de formato padrão "D" (data por extenso), que LongDatePattern é mapeada diretamente para a propriedade.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • A cadeia de caracteres de formato padrão "f" (data/hora completa), que produz uma cadeia de caracteres de resultado que concatena as subcadeias ShortTimePattern de caracteres produzidas pelas LongDatePattern Propriedades e.The "f" (full date / short time) standard format string, which produces a result string that concatenates the substrings produced by the LongDatePattern and ShortTimePattern properties.

  • A cadeia de caracteres de formato padrão "F" (data/hora completa), que mapeia diretamente FullDateTimePattern para a propriedade.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Como não definimos explicitamente esse valor de propriedade, ele é gerado dinamicamente concatenando as LongDatePattern Propriedades e. LongTimePatternBecause we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

O exemplo também mostra como alterar o nome de era de uma cultura cujo calendário tem uma única era.The example also shows how to change the era name for a culture whose calendar has a single era. Nesse caso, a cultura en-US usa o calendário gregoriano, que é representado por um GregorianCalendar objeto.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. A GregorianCalendar classe dá suporte a uma única época, que nomeia d.c.The GregorianCalendar class supports a single era, which it names A.D. (Anno Domini).(Anno Domini). O exemplo altera o nome de era para C.E.The example changes the era name to C.E. (Era comum) substituindo o especificador de formato personalizado "g" na cadeia de caracteres de FullDateTimePattern formato atribuída à propriedade com uma cadeia de caracteres literal.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. O uso de uma cadeia de caracteres literal é necessário, pois o nome da era normalmente é GetEraName retornado pelo método de dados privados nas tabelas de cultura fornecidas pelo .NET Framework ou pelo sistema operacional Windows.The use of a literal string is necessary, because the era name is typically returned by the GetEraName method from private data in the culture tables supplied by either the .NET Framework or the Windows operating system.

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 horaParsing date and time strings

A análise envolve a conversão da representação de cadeia de caracteres de uma data DateTime e DateTimeOffset hora em um valor ou.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Ambos os Parsetipos incluem os métodos, TryParse, ParseExacte TryParseExact para dar suporte a operações de análise.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Os Parse métodos TryParse e convertem uma cadeia de caracteres que pode ter uma variedade de ParseExact formatos TryParseExact , enquanto que e exigem que a cadeia de caracteres tenha um formato ou formatos definidos.The Parse and TryParse methods convert a string that can have a variety of formats, whereas ParseExact and TryParseExact require that the string have a defined format or formats. Se a operação de análise falhar Parse e ParseExact lançar uma exceção, enquanto TryParse e TryParseExact retornará false.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Os métodos de análise implicitamente ou explicitamente usam um DateTimeStyles valor de enumeração para determinar quais elementos de estilo (como espaço em branco à esquerda, à direita ou interno) podem estar presentes na cadeia de caracteres a ser analisada e como interpretar a cadeia de caracteres analisada ou qualquer faltante elementos.The parsing methods implicitly or explicitly use a DateTimeStyles enumeration value to determine which style elements (such as leading, trailing, or inner white space) can be present in the string to be parsed, and how to interpret the parsed string or any missing elements. Se você não fornecer um DateTimeStyles valor ao chamar o Parse método ou TryParse , o padrão será DateTimeStyles.AllowWhiteSpaces, que é um estilo composto que inclui os DateTimeStyles.AllowLeadingWhitesinalizadores, DateTimeStyles.AllowTrailingWhitee DateTimeStyles.AllowInnerWhite .If you don't provide a DateTimeStyles value when you call the Parse or TryParse method, the default is DateTimeStyles.AllowWhiteSpaces, which is a composite style that includes the DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, and DateTimeStyles.AllowInnerWhite flags. Para os ParseExact métodos TryParseExact e, 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.For the ParseExact and TryParseExact methods, the default is DateTimeStyles.None; the input string must correspond precisely to a particular custom date and time format string.

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.The parsing methods also implicitly or explicitly use a DateTimeFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Se você não fornecer um DateTimeFormatInfo objeto, o DateTimeFormatInfo objeto para a cultura de thread atual será usado por padrão.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Para obter mais informações sobre a análise de cadeias de caracteres de data e hora, consulte os métodos DateTime.Parsede análise DateTimeOffset.ParseExactindividuais, DateTimeOffset.TryParseExactcomo, DateTime.TryParse, e.For more information about parsing date and time strings, see the individual parsing methods, such as DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, and DateTimeOffset.TryParseExact.

O exemplo a seguir ilustra a natureza sensível à cultura da análise de cadeias de caracteres de data e hora.The following example illustrates the culture-sensitive nature of parsing date and time strings. Ele tenta analisar duas cadeias de caracteres de data usando as convenções das culturas en-US, en-GB, fr-FR e fi-FI.It tries to parse two date strings by using the conventions of the en-US, en-GB, fr-FR, and fi-FI cultures. A data que é interpretada como 8/18/2014 na cultura en-US gera FormatException uma exceção nas outras três culturas porque 18 é interpretado como o número do mês.The date that is interpreted as 8/18/2014 in the en-US culture throws a FormatException exception in the other three cultures because 18 is interpreted as the month number. 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.1/2/2015 is parsed as the second day of the first month in the en-US culture, but as the first day of the second month in the remaining cultures.

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:Date and time strings are typically parsed for two reasons:

  • Para converter a entrada do usuário em um valor de data e hora.To convert user input into a date and time value.

  • Para fazer ida e volta de 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.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

As seções a seguir discutem essas duas operações com mais detalhes.The following sections discuss these two operations in greater detail.

Analisando cadeias de caracteres do usuárioParsing user strings

Ao analisar a entrada de cadeias de caracteres de data e hora pelo usuário, você DateTimeFormatInfo sempre deve criar uma instância de um objeto que reflita as configurações culturais do usuário, incluindo as personalizações que o usuário possa ter feito.When you parse date and time strings input by the user, you should always instantiate a DateTimeFormatInfo object that reflects the user's cultural settings, including any customizations the user may have made. Caso contrário, o objeto de data e hora pode ter valores incorretos.Otherwise, the date and time object may have incorrect values. Para obter informações sobre como criar uma DateTimeFormatInfo instância de um objeto que reflete as personalizações culturais do usuário, consulte a seção DateTimeFormatInfo e dados dinâmicos .For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

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 faz isso.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. Nesse caso, a cultura de sistema padrão é en-US, mas o usuário usou o painel de controle, região e idioma para alterar o padrão de data abreviada do padrão "M/d/aaaa" para "yy/mm/dd".In this case, the default system culture is en-US, but the user has used Control Panel, Region and Language to change the short date pattern from its default of "M/d/yyyy" to "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 DateTimeFormatInfo é analisada por um objeto que também reflete as configurações do usuário (substituições), a operação de análise retorna um resultado correto.When the user enters a string that reflects user settings, and the string is parsed by a DateTimeFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. No entanto, quando a cadeia de caracteres é DateTimeFormatInfo analisada por um objeto que reflete as configurações culturais padrão en-US, o FormatException método de análise gera uma exceção porque ela interpreta 14 como o número do mês, não os dois últimos dígitos do ano.However, when the string is parsed by a DateTimeFormatInfo object that reflects standard en-US cultural settings, the parsing method throws a FormatException exception because it interprets 14 as the number of the month, not the last two digits of the year.

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 horaSerializing and deserializing date and time data

Os dados serializados de data e hora são esperados para a viagem de ida e volta; ou seja, todos os valores serializados e desserializados devem ser idênticos.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Se um valor de data e hora representa um único momento no tempo, o valor desserializado deve representar o mesmo momento no tempo, independentemente da cultura ou do fuso horário do sistema no qual ele foi restaurado.If a date and time value represents a single moment in time, the deserialized value should represent the same moment in time regardless of the culture or time zone of the system on which it was restored. Para dados de data e hora de viagem de ida e volta com êxito, você deve usar as convenções da cultura invariável, que InvariantInfo é retornada pela propriedade, para gerar e analisar os dados.To round-trip date and time data successfully, you must use the conventions of the invariant culture, which is returned by the InvariantInfo property, to generate and parse the data. As operações de formatação e análise nunca devem refletir as convenções da cultura padrão.The formatting and parsing operations should never reflect the conventions of the default culture. Se você usar configurações culturais padrão, a portabilidade dos dados será estritamente limitada; Ele pode ser desserializado com êxito apenas em um thread cujas configurações específicas de cultura são idênticas às do thread no qual ele foi serializado.If you use default cultural settings, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose cultural-specific settings are identical to those of the thread on which it was serialized. Em alguns casos, isso significa que os dados não podem nem ser serializados e desserializados com êxito no mesmo sistema.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Se o componente de tempo 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".If the time component of a date and time value is significant, it should also be converted to UTC and serialized by using the "o" or "r" standard format string. Os dados de tempo podem ser restaurados chamando um método de análise e passando-o para a cadeia de caracteres de formato apropriada junto com provider a cultura invariável como o argumento.The time data can then be restored by calling a parsing method and passing it the appropriate format string along with the invariant culture as the provider argument.

O exemplo a seguir ilustra o processo de ida e volta de um valor de data e hora.The following example illustrates the process of round-tripping a date and time value. Ele serializa uma data e hora em um sistema que observa os EUA Hora do Pacífico e cuja cultura atual é en-US.It serializes a date and time on a system that observes U.S. Pacific time and whose current culture is en-US.

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)

Ele desserializa os dados em um sistema no fuso horário Bruxelas, Copenhague, Madri e Paris e cuja cultura atual é fr-FR.It deserializes the data on a system in the Brussels, Copenhagen, Madrid and Paris time zone and whose current culture is fr-FR. A data restaurada é de nove horas depois da data original, que reflete o ajuste de fuso horário de oito horas atrás de UTC para uma hora à frente do UTC.The restored date is nine hours later than the original date, which reflects the time zone adjustment from eight hours behind UTC to one hour ahead of UTC. A data original e a data de restauração representam o mesmo momento determinado.Both the original date and the restored date represent the same moment in time.

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() DateTimeFormatInfo() DateTimeFormatInfo() DateTimeFormatInfo()

Inicializa uma nova instância gravável da classe DateTimeFormatInfo que é independente da cultura (invariável).Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Propriedades

AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames 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.Gets or sets a one-dimensional array of type String containing the culture-specific abbreviated names of the days of the week.

AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames

Obtém ou define uma matriz de cadeia de caracteres de nomes de meses abreviados associada ao objeto DateTimeFormatInfo atual.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames

Obtém ou define uma matriz unidimensional de cadeia de caracteres que contém os nomes dos meses abreviados, específicos da cultura.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator AMDesignator AMDesignator AMDesignator

Obtém ou define o designador de cadeia de caracteres de horas que são "ante meridiem" (antes do meio-dia).Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar Calendar Calendar Calendar

Obtém ou define o calendário a ser usado para a cultura atual.Gets or sets the calendar to use for the current culture.

CalendarWeekRule CalendarWeekRule CalendarWeekRule CalendarWeekRule

Obtém ou define um valor que especifica qual regra é usada para determinar a primeira semana do ano.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Obtém o objeto DateTimeFormatInfo somente leitura que formata valores com base na cultura atual.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator DateSeparator DateSeparator DateSeparator

Define a cadeia de caracteres que separa a os componentes de uma data, ou seja, o ano, mês e dia.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames DayNames DayNames 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.Gets or sets a one-dimensional string array that contains the culture-specific full names of the days of the week.

FirstDayOfWeek FirstDayOfWeek FirstDayOfWeek FirstDayOfWeek

Obtém ou define o primeiro dia da semana.Gets or sets the first day of the week.

FullDateTimePattern FullDateTimePattern FullDateTimePattern FullDateTimePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor temporal longo e valor de data longo.Gets or sets the custom format string for a long date and long time value.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Obtém o objeto DateTimeFormatInfo padrão somente leitura que é independente da cultura (invariável).Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtém um valor que indica se o objeto DateTimeFormatInfo é somente leitura.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern LongDatePattern LongDatePattern LongDatePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de data longa.Gets or sets the custom format string for a long date value.

LongTimePattern LongTimePattern LongTimePattern LongTimePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor temporal extenso.Gets or sets the custom format string for a long time value.

MonthDayPattern MonthDayPattern MonthDayPattern MonthDayPattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de mês e de dia.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames

Obtém ou define uma matriz de cadeia de caracteres de nomes de meses associada ao objeto DateTimeFormatInfo atual.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames MonthNames MonthNames 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.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName NativeCalendarName NativeCalendarName NativeCalendarName

Obtém o nome nativo do calendário associado ao objeto DateTimeFormatInfo atual.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator PMDesignator PMDesignator PMDesignator

Obtém ou define o designador de cadeia de caracteres de horas que são "post meridiem" (depois do meio-dia).Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern RFC1123Pattern RFC1123Pattern 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).Gets the custom format string for a time value that is based on the Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123 specification.

ShortDatePattern ShortDatePattern ShortDatePattern ShortDatePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de data abreviada.Gets or sets the custom format string for a short date value.

ShortestDayNames ShortestDayNames ShortestDayNames ShortestDayNames

Obtém ou define uma matriz de cadeia de caracteres dos nomes de dias abreviados únicos mais curtos associados ao objeto DateTimeFormatInfo atual.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern ShortTimePattern ShortTimePattern ShortTimePattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor temporal abreviado.Gets or sets the custom format string for a short time value.

SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern

Obtém a cadeia de caracteres de formato personalizado para um valor de data e hora classificável.Gets the custom format string for a sortable date and time value.

TimeSeparator TimeSeparator TimeSeparator TimeSeparator

Obtém ou define a cadeia de caracteres que separa os componentes de tempo, ou seja, a hora, os minutos e os segundos.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern 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.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern YearMonthPattern YearMonthPattern YearMonthPattern

Obtém ou define a cadeia de caracteres de formato personalizado para um valor de ano e mês.Gets or sets the custom format string for a year and month value.

Métodos

Clone() Clone() Clone() Clone()

Cria uma cópia superficial do DateTimeFormatInfo.Creates a shallow copy of the DateTimeFormatInfo.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek)

Retorna o nome abreviado, específico da cultura, do dia da semana especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.Returns the culture-specific abbreviated name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32)

Retorna a cadeia de caracteres que contém o nome abreviado da era especificada, se houver uma abreviação.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32)

Retorna o nome abreviado da cultura específica do mês especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetAllDateTimePatterns() GetAllDateTimePatterns() GetAllDateTimePatterns() GetAllDateTimePatterns()

Retorna todos os padrões padrão nos quais os valores de data e hora podem ser formatados.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) 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.Returns all the patterns in which date and time values can be formatted using the specified standard format string.

GetDayName(DayOfWeek) GetDayName(DayOfWeek) GetDayName(DayOfWeek) GetDayName(DayOfWeek)

Retorna o nome completo, específico da cultura, do dia da semana especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.Returns the culture-specific full name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetEra(String) GetEra(String) GetEra(String) GetEra(String)

Retorna o inteiro que representa a era especificada.Returns the integer representing the specified era.

GetEraName(Int32) GetEraName(Int32) GetEraName(Int32) GetEraName(Int32)

Retorna a cadeia de caracteres que contém o nome da era especificado.Returns the string containing the name of the specified era.

GetFormat(Type) GetFormat(Type) GetFormat(Type) GetFormat(Type)

Retorna um objeto do tipo especificado que fornece um serviço de formatação de data e hora.Returns an object of the specified type that provides a date and time formatting service.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider)

Retorna o objeto DateTimeFormatInfo associado ao IFormatProvider especificado.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

GetMonthName(Int32) GetMonthName(Int32) GetMonthName(Int32) GetMonthName(Int32)

Retorna o nome completo da cultura específica do mês especificado com base na cultura associada ao objeto DateTimeFormatInfo atual.Returns the culture-specific full name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek)

Obtém o nome abreviado do dia mais curto de um dia especificado da semana associado ao objeto DateTimeFormatInfo atual.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo)

Retorna um wrapper DateTimeFormatInfo de somente leitura.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) 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.Sets the custom date and time format strings that correspond to a specified standard format string.

ToString() ToString() ToString() ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)

Implantações explícitas de interface

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Aplica-se a

Veja também