DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo Class

Definición

Proporciona información específica de la referencia cultural acerca del formato de los valores de fecha y 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
Herencia
DateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfo
Atributos
Implementaciones

Ejemplos

El ejemplo siguiente usa la reflexión para obtener las propiedades de la DateTimeFormatInfo objeto para la referencia cultural inglés (Estados Unidos).The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. Muestra el valor de las propiedades que contienen cadenas de formato personalizado y usa estas cadenas para mostrar fechas con el formato.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

Comentarios

Las propiedades de la DateTimeFormatInfo clase contienen información específica de la referencia cultural para dar formato o analizar los valores de fecha y hora como el siguiente:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Los patrones que se utilizan para dar formato a valores de fecha.The patterns used to format date values.

  • Los patrones que se utilizan para dar formato a valores de tiempo.The patterns used to format time values.

  • Los nombres de los días de la semana.The names of the days of the week.

  • Los nombres de los meses del año.The names of the months of the year.

  • A.M.The A.M. y p. M.and P.M. designadores de utilizados en los valores de hora.designators used in time values.

  • El calendario en la que se expresan las fechas.The calendar in which dates are expressed.

En esta sección:In this section:

Instancias de un objeto DateTimeFormatInfoInstantiating a DateTimeFormatInfo object

Un DateTimeFormatInfo objeto puede representar las convenciones de formato de la referencia cultural invariable, una referencia cultural específica, la referencia cultural actual o una referencia cultural neutra.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. En esta sección se describe cómo crear una instancia de cada tipo de DateTimeFormatInfo objeto.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Instancias de un objeto DateTimeFormatInfo para la referencia culturalInstantiating a DateTimeFormatInfo object for the invariant culture

La referencia cultural invariable representa una referencia cultural que no tiene en cuenta la referencia cultural.The invariant culture represents a culture that is culture-insensitive. Se basa en el idioma inglés, pero no en cualquier angloparlante país o región determinados.It is based on the English language, but not on any specific English-speaking country/region. Aunque los datos de referencias culturales específicas pueden ser dinámicos y se pueden cambiar para reflejar las convenciones culturales nuevo o las preferencias del usuario, no cambian los datos de la referencia cultural invariable.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. Puede crear instancias de un DateTimeFormatInfo objeto que representa las convenciones de formato de la referencia cultural de las maneras siguientes:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

El ejemplo siguiente usa cada uno de estos métodos para crear instancias de un DateTimeFormatInfo objeto que representa la referencia cultural invariable.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. A continuación, indica si el objeto es de solo lectura.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      

Instancias de un objeto DateTimeFormatInfo para una referencia cultural específicaInstantiating a DateTimeFormatInfo object for a specific culture

Una referencia cultural específica representa el idioma que se habla en un determinado país o región.A specific culture represents a language that is spoken in a particular country/region. Por ejemplo, en-US es una referencia cultural que representa el idioma inglés de Estados Unidos y en-CA es una referencia cultural que representa el idioma inglés de 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. Puede crear instancias de un DateTimeFormatInfo objeto que representa las convenciones de formato de una referencia cultural específica de las maneras siguientes:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

El ejemplo siguiente ilustra cada una de estas formas de crear una instancia de un DateTimeFormatInfo objeto e indica si el objeto resultante es de solo lectura.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

Instancias de un objeto DateTimeFormatInfo para una referencia cultural neutraInstantiating a DateTimeFormatInfo object for a neutral culture

Una referencia cultural neutra representa una referencia cultural o idioma que es independiente de un país o región; suele ser el elemento primario de referencias culturales específicas de uno o más.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 ejemplo, Fr es una referencia cultural neutra para el idioma francés y el elemento primario de la referencia cultural fr-FR.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. Puede crear instancias de un DateTimeFormatInfo objeto que representa las convenciones de formato de una referencia cultural neutra de la misma forma que creas un DateTimeFormatInfo objeto que representa las convenciones de formato de una referencia cultural concreta.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. Además, puede recuperar una referencia cultural neutra DateTimeFormatInfo objeto mediante la recuperación de una referencia cultural específica de una referencia cultural neutra CultureInfo.Parent propiedad y recuperar el DateTimeFormatInfo objeto devuelto por su CultureInfo.DateTimeFormat propiedad.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 la referencia cultural principal representa la referencia cultural, el valor devuelto DateTimeFormatInfo objeto es de lectura/escritura.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. El ejemplo siguiente ilustra las siguientes maneras de crear instancias de un DateTimeFormatInfo objeto que representa una referencia cultural 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       

Nota

En las versiones de .NET Framework 1.0 a través de .NET Framework 3,5.NET Framework 3.5, intenta recuperar un DateTimeFormatInfo objeto que refleja las convenciones de formato de una referencia cultural neutra produce un NotSupportedException excepción.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.

Sin embargo, una referencia cultural neutra carece de información de formato de referencia cultural específica, ya que es independiente de un país o región determinados.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. En lugar de rellenar el DateTimeFormatInfo objeto con valores genéricos, .NET Framework devuelve un DateTimeFormatInfo que refleja las convenciones de formato de una determinada referencia cultural que es un elemento secundario de la referencia cultural 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 ejemplo, el DateTimeFormatInfo para la referencia cultural neutra en refleja las convenciones de formato de la referencia cultural en-US, de objeto y el DateTimeFormatInfo de objeto para la referencia cultural fr refleja las convenciones de formato de la referencia cultural 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.

Puede usar código similar al siguiente para determinar las convenciones de formato de la referencia cultural concreta representa una referencia cultural neutra.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. En el ejemplo se usa la reflexión para comparar la DateTimeFormatInfo propiedades de una referencia cultural neutra con las propiedades de una referencia cultural de secundarios específicos.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Se considera que dos calendarios sean equivalentes si son del mismo tipo de calendario y, de calendario gregoriano, calendarios, si sus GregorianCalendar.CalendarType propiedades tienen 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
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

Instancias de un objeto DateTimeFormatInfo para la referencia cultural actualInstantiating a DateTimeFormatInfo object for the current culture

Puede crear instancias de un DateTimeFormatInfo objeto que representa las convenciones de formato de la referencia cultural actual de las maneras siguientes:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

El ejemplo siguiente usa cada uno de estos métodos para crear instancias de un DateTimeFormatInfo objeto que representa las convenciones de formato de la referencia cultural actual.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. A continuación, indica si el objeto es de solo lectura.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

Puede crear una escritura DateTimeFormatInfo objeto que representa las convenciones de la referencia cultural del subproceso actual en una de estas maneras:You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

El ejemplo siguiente muestra cada forma de crear instancias de lectura y escritura DateTimeFormatInfo de objetos y muestra el valor de su IsReadOnly propiedad.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

En Windows, el usuario puede invalidar algunos de los DateTimeFormatInfo valores de propiedad usados en las operaciones a través de análisis y formato el región e idioma aplicación en el Panel de Control.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 ejemplo, un usuario cuya referencia cultural es inglés (Estados Unidos) puede mostrar valores de hora larga con un reloj de 24 horas (en el formato hh: mm:) en lugar de la predeterminada de 12 horas (en el formato 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). El DateTimeFormatInfo los objetos recuperados de las maneras en que se describe anteriormente reflejan todos estas invalidaciones del usuario.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Si esto es indeseable, puede crear un NumberFormatInfo objeto que no refleje usuario reemplaza (y también es de lectura/escritura en lugar de solo lectura) mediante una llamada a la CultureInfo.CultureInfo(String, Boolean) constructor y proporcionar un valor de false para el useUserOverride 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. El ejemplo siguiente muestra esto para un sistema cuya referencia cultural actual es inglés (Estados Unidos) y cuyo patrón de mucho tiempo se ha cambiado el valor predeterminado es: mm: ss a hh: mm:.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 y dinámico de datosDateTimeFormatInfo and dynamic data

Los datos específicos de referencias culturales para dar formato a valores de fecha y hora proporcionados por el DateTimeFormatInfo clase es dinámica, como los datos de referencia culturales proporcionados por el CultureInfo clase.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. No debe hacer ninguna suposición sobre la estabilidad de los valores de DateTimeFormatInfo objetos que están asociados a determinado CultureInfo objetos.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Solo los datos proporcionados por la referencia cultural y los correspondientes DateTimeFormatInfo objeto es estable.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. Otros datos pueden cambiar entre sesiones de aplicación o incluso mientras se ejecuta la aplicación.Other data can change between application sessions or even while your application is running. Hay cuatro orígenes principales de cambio:There are four major sources of change:

  • Actualizaciones del sistema.System updates. Cambian las preferencias culturales, como el calendario preferido o habitual formatos de fecha y hora con el tiempo.Cultural preferences such as the preferred calendar or customary date and time formats change over time. Cuando esto sucede, Windows Update incluye los cambios realizados en el DateTimeFormatInfo valor de propiedad para una referencia cultural determinada.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Referencias culturales de reemplazo.Replacement cultures. La CultureAndRegionInfoBuilder clase puede utilizarse para reemplazar los datos de una referencia cultural existente.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Cambios en cascada en los valores de propiedad.Cascading changes to property values. Pueden cambiar varias propiedades relacionadas con la referencia cultural en tiempo de ejecución, a su vez, lo que hace que DateTimeFormatInfo datos para cambiar.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Por ejemplo, la referencia cultural actual se puede cambiar mediante programación o a través de la acción del usuario.For example, the current culture can be changed either programmatically or through user action. Cuando esto sucede, el DateTimeFormatInfo objeto devuelto por la CurrentInfo propiedad cambia a un objeto asociado a la referencia cultural actual.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. De forma similar, puede cambiar el calendario de una referencia cultural, que puede causar cambios numerosas DateTimeFormatInfo los valores de propiedad.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Preferencias del usuario.User preferences. Los usuarios de la aplicación pueden optar por invalidar algunos de los valores asociados con la referencia cultural actual del sistema a través de las opciones de configuración regional y de idioma en el Panel de Control.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 ejemplo, los usuarios pueden elegir mostrar la fecha en un formato diferente.For example, users might choose to display the date in a different format. Si el CultureInfo.UseUserOverride propiedad está establecida en true, las propiedades de la DateTimeFormatInfo objeto también se recupera de la configuración del usuario.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. Si la configuración de usuario no es compatible con la referencia cultural asociada con el CultureInfo objeto (por ejemplo, si el calendario seleccionado no es uno de los calendarios indicados por el OptionalCalendars propiedad), los resultados de los métodos y los valores de las propiedades no están definidos.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 la posibilidad de inconsistencia de datos, todas las propiedades que se puede invalidar el usuario de un DateTimeFormatInfo objetos se inicializan cuando se crea el objeto.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. Todavía hay una posibilidad de incoherencia, ya sea atómico ni la creación de objetos ni el proceso de reemplazo de usuario y pueden cambiar los valores pertinentes durante la creación del 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. Sin embargo, esta situación debería ser muy poco habitual.However, this situation should be extremely rare.

Puede controlar si las invalidaciones del usuario se reflejan en DateTimeFormatInfo objetos que representan la misma referencia cultural que la referencia cultural del sistema.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. La tabla siguiente enumeran las formas en que un DateTimeFormatInfo objeto se pueden recuperar e indica si el objeto resultante refleja invalidaciones del usuario.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Origen de un objeto CultureInfo y DateTimeFormatInfoSource of CultureInfo and DateTimeFormatInfo object Refleja las invalidaciones del usuarioReflects user overrides
PropiedadCultureInfo.CurrentCulture.DateTimeFormat CultureInfo.CurrentCulture.DateTimeFormat property Yes
PropiedadDateTimeFormatInfo.CurrentInfo DateTimeFormatInfo.CurrentInfo property Yes
Método CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method Yes
Método CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NoNo
Constructor CultureInfo.CultureInfo(String)CultureInfo.CultureInfo(String) constructor Yes
Constructor CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Depende de valor de useUserOverride parámetroDepends on value of useUserOverride parameter

A menos que haya una razón de peso para no hacerlo, debe respetar las invalidaciones del usuario cuando se usa el DateTimeFormatInfo objetos en las aplicaciones cliente para dar formato y analizar la entrada de usuario o para mostrar los datos.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 las aplicaciones de servidor o aplicaciones desatendidas, no debería.For server applications or unattended applications, you should not. Sin embargo, si está utilizando el DateTimeFormatInfo objeto ya sea explícitamente o implícitamente para conservar los datos de fecha y hora en forma de cadena, debería usar un DateTimeFormatInfo debe especificar el objeto que refleja las convenciones de formato de la referencia cultural invariable, o bien un cadena que usa independientemente de la referencia cultural de formato de fecha y hora personalizado.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.

Aplicar formato a fechas y horasFormatting dates and times

Un DateTimeFormatInfo objeto sirve implícita o explícitamente en todas las fecha y hora operaciones de formato.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Estos incluyen llamadas a los métodos siguientes:These include calls to the following methods:

Todos los datos y realizar operaciones de formato de hora de uso de un IFormatProvider implementación.All date and time formatting operations make use of an IFormatProvider implementation. El IFormatProvider interfaz incluye un único método, IFormatProvider.GetFormat(Type).The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Este método de devolución de llamada se transfiere un Type objeto que representa el tipo necesario para proporcionar información de formato.This callback method is passed a Type object that represents the type needed to provide formatting information. El método devuelve una instancia de ese tipo o null si no puede proporcionar una instancia del tipo.The method returns either an instance of that type or null if it cannot provide an instance of the type. .NET Framework incluye dos IFormatProvider implementaciones para dar formato a fechas y horas:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Si un IFormatProvider implementación no se proporciona a un método de formato de forma explícita, el CultureInfo objeto devuelto por la CultureInfo.CurrentCulture se utiliza la propiedad que representa la referencia cultural del subproceso actual.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.

El ejemplo siguiente ilustra la relación entre el IFormatProvider interfaz y la DateTimeFormatInfo clase en operaciones de formato.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Define un personalizado IFormatProvider implementación cuyo GetFormat método muestra el tipo del objeto solicitado por la operación de formato.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. Si está solicitando un DateTimeFormatInfo objeto, el método proporciona la DateTimeFormatInfo objeto para la referencia cultural del subproceso actual.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Como la salida muestra el ejemplo, el Decimal.ToString(IFormatProvider) las solicitudes de métodos un DateTimeFormatInfo objeto para proporcionar información de formato, mientras que el String.Format(IFormatProvider, String, Object[]) las solicitudes de métodos NumberFormatInfo y DateTimeFormatInfo objetos, así como un ICustomFormatter implementación de.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

Cadenas de formato y propiedades de DateTimeFormatInfoFormat strings and DateTimeFormatInfo properties

La DateTimeFormatInfo objeto incluye tres tipos de propiedades que se usan para dar formato a las operaciones con valores de fecha y hora:The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

El cadenas con formato de fecha y hora estándar, como "d", "D", "f" y "F", son alias que corresponden a determinado DateTimeFormatInfo propiedades del modelo 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. La mayoría de los cadenas con formato de fecha y hora personalizado están relacionadas con cadenas o subcadenas que una operación de formato que se inserta en la secuencia 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. La tabla siguiente muestra la fecha estándar y personalizada y los especificadores de formato de hora y sus asociados DateTimeFormatInfo propiedades.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Para obtener información detallada sobre cómo usar estos especificadores de formato, vea Standard Date and Time Format Strings y Custom Date and Time Format Strings.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Tenga en cuenta que cada cadena de formato estándar corresponde a un DateTimeFormatInfo propiedad cuyo valor es una cadena de formato de tiempo y fecha personalizada.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Los especificadores individuales en esta cadena de formato personalizado correspondan a su vez sí DateTimeFormatInfo propiedades.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. La tabla se enumeran solo los DateTimeFormatInfo propiedades para que las cadenas de formato estándar son alias y hace no las propiedades de lista que pueden tener acceso a cadenas de formato personalizado que se asigna a las propiedades de un 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. Además, la tabla muestran los especificadores de formato personalizado que se corresponden con DateTimeFormatInfo propiedades.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

Especificador de formatoFormat specifier Propiedades asociadasAssociated properties
"d" (fecha corta; la cadena de formato estándar)"d" (short date; standard format string) ShortDatePattern, para definir el formato general de la cadena de resultado.ShortDatePattern, to define the overall format of the result string.
"D" (fecha larga; la cadena de formato estándar)"D" (long date; standard format string) LongDatePattern, para definir el formato general de la cadena de resultado.LongDatePattern, to define the overall format of the result string.
"f" (completos de fecha / hora; estándar a corto cadena de formato)"f" (full date / short time; standard format string) LongDatePattern, para definir el formato del componente de fecha de la cadena de resultado.LongDatePattern, to define the format of the date component of the result string.

ShortTimePattern, para definir el formato del componente de hora de la cadena de resultado.ShortTimePattern, to define the format of the time component of the result string.
"F" (full date / largos de tiempo; la cadena de formato estándar)"F" (full date / long time; standard format string) LongDatePattern, para definir el formato del componente de fecha de la cadena de resultado.LongDatePattern, to define the format of the date component of the result string.

LongTimePattern, para definir el formato del componente de hora de la cadena de resultado.LongTimePattern, to define the format of the time component of the result string.
"g" (fecha general y hora corta; la cadena de formato estándar)"g" (general date / short time; standard format string) ShortDatePattern, para definir el formato del componente de fecha de la cadena de resultado.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePattern, para definir el formato del componente de hora de la cadena de resultado.ShortTimePattern, to define the format of the time component of the result string.
"G" (fecha general / largo tiempo; estándar cadena de formato)"G" (general date / long time; standard format string) ShortDatePattern, para definir el formato del componente de fecha de la cadena de resultado.ShortDatePattern, to define the format of the date component of the result string.

LongTimePattern, para definir el formato del componente de hora de la cadena de resultado.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (mes/día; la cadena de formato estándar)"M", "m" (month/day; standard format string) MonthDayPattern, para definir el formato general de la cadena de resultado.MonthDayPattern, to define the overall format of the result string.
"O", "o" (ida y vuelta de fecha y hora; la cadena de formato estándar)"O", "o" (round-trip date/time; standard format string) Ninguno.None.
"R", "r" (RFC1123; la cadena de formato estándar)"R", "r" (RFC1123; standard format string) RFC1123Pattern, para definir una cadena de resultado que se ajusta a la norma RFC 1123.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. La propiedad es de solo lectura.The property is read-only.
"s" (fecha y hora que se puede ordenar; la cadena de formato estándar)"s" (sortable date/time; standard format string) SortableDateTimePattern, para definir una cadena de resultado que se ajusta al estándar ISO 8601.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. La propiedad es de solo lectura.The property is read-only.
"t" (hora corta; la cadena de formato estándar)"t" (short time; standard format string) ShortTimePattern, para definir el formato general de la cadena de resultado.ShortTimePattern, to define the overall format of the result string.
"T" (mucho tiempo; la cadena de formato estándar)"T" (long time; standard format string) LongTimePattern, para definir el formato general de la cadena de resultado.LongTimePattern, to define the overall format of the result string.
"u" (fecha y hora que se puede ordenar universal; la cadena de formato estándar)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, para definir una cadena de resultado que se ajusta al estándar ISO 8601 de hora universal coordinada.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. La propiedad es de solo lectura.The property is read-only.
"U" (fecha/hora completa universal; la cadena de formato estándar)"U" (universal full date/time; standard format string) FullDateTimePattern, para definir el formato general de la cadena de resultado.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (mes y año; la cadena de formato estándar)"Y", "y" (year month; standard format string) YearMonthPattern, para definir el formato general de la cadena de resultado.YearMonthPattern, to define the overall format of the result string.
"ddd" (especificador de formato personalizado)"ddd" (custom format specifier) AbbreviatedDayNames, para incluir el nombre abreviado del día de la semana en la cadena 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) Las llamadas del GetEraName método para insertar el nombre de la era en la cadena 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 el nombre de mes abreviado en la cadena de resultado.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (especificador de formato personalizado)"MMMM" (custom format specifier) MonthNames o MonthGenitiveNames, para incluir el nombre completo del mes en la cadena de resultado.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (especificador de formato personalizado)"t" (custom format specifier) AMDesignator o PMDesignator, para incluir el primer carácter del designador AM/PM en la cadena 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) AMDesignator o PMDesignator, para incluir el designador AM/PM completo en la cadena 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 el separador de hora en la cadena de resultado.TimeSeparator, to include the time separator in the result string.
"/" (especificador de formato personalizado)"/" (custom format specifier) DateSeparator, para incluir el separador de fecha en la cadena de resultado.DateSeparator, to include the date separator in the result string.

Modificar las propiedades de DateTimeFormatInfoModifying DateTimeFormatInfo properties

Puede cambiar la cadena de resultado generada por las cadenas de formato de fecha y hora mediante la modificación de las propiedades asociadas de una escritura DateTimeFormatInfo objeto.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 si un DateTimeFormatInfo objeto es modificable, use el IsReadOnly propiedad.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. Para personalizar un DateTimeFormatInfo objeto de esta manera:To customize a DateTimeFormatInfo object in this way:

  1. Crear una copia de lectura/escritura de un DateTimeFormatInfo objeto cuyas convenciones de formato que desea modificar.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Consulte la instancias de un objeto DateTimeFormatInfo sección.)(See the Instantiating a DateTimeFormatInfo object section.)

  2. Modifique la propiedad o propiedades que se utilizan para generar la cadena de resultado deseado.Modify the property or properties that are used to produce the desired result string. (Para obtener información sobre el uso de métodos de formato cómo DateTimeFormatInfo las propiedades para definir cadenas de resultado, consulte la sección anterior, cadenas de formato y propiedades de DateTimeFormatInfo.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Usar personalizado DateTimeFormatInfo que ha creado como objeto la IFormatProvider argumento en las llamadas a métodos de formato.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Hay otras dos maneras de cambiar el formato de una cadena de resultado:There are two other ways to change the format of a result string:

  • Puede usar el CultureAndRegionInfoBuilder clase para definir una referencia cultural personalizada (una referencia cultural que tiene un nombre único y que complementa existente referencias culturales) o una referencia cultural de reemplazo (uno que se utiliza en lugar de una referencia cultural 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). Puede guardar y tener acceso a esta referencia cultural mediante programación tal como lo haría con cualquier CultureInfo objeto admitido por .NET Framework.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Si la cadena de resultado no es la referencia cultural y no sigue un formato predefinido, puede usar una cadena de formato de tiempo y fecha 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 ejemplo, si serializa datos de fecha y hora en el formato aaaammddhhmmss, puede generar la cadena de resultado, pase la cadena de formato personalizado para el DateTime.ToString(String) método y se puede convertir la cadena de resultado a un DateTime valor mediante una llamada a la 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.

Cambiar el patrón de fecha cortaChanging the short date pattern

El ejemplo siguiente cambia el formato de una cadena de resultado generada por la cadena de formato estándar "d" (fecha corta).The following example changes the format of a result string produced by the "d" (short date) standard format string. Cambia asociado ShortDatePattern propiedad en-US o referencia cultural de inglés (Estados Unidos) a su valor predeterminado de "M/d/yyyy" a "yyyy'-" MM"-"dd"y usa el formato estándar"d"de cadena para mostrar la fecha antes y después el ShortDatePattern es propiedad puede cambiar.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

Cambiar el carácter de separador de fechaChanging the date separator character

En el ejemplo siguiente se cambia el carácter de separador de fecha en un DateTimeFormatInfo objeto que representa las convenciones de formato de la referencia cultural fr-FR.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. El ejemplo utiliza la cadena de formato estándar "g" para mostrar la fecha antes y después el DateSeparator se cambia la propiedad.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

Cambio de abreviaturas de nombres y el patrón de fecha largaChanging day name abbreviations and the long date pattern

En algunos casos, el patrón de fecha larga, que normalmente se muestra el día completo y el nombre del mes junto con el número del día del mes y año, puede ser demasiado largo.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. En el ejemplo siguiente, se acorta el patrón de fecha larga de la referencia cultural de en-US devolver una abreviatura de nombre de un carácter o caracteres de dos días seguido del número de días, la abreviatura de nombre de mes y año.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. Esto lo consigue asignando más cortas abreviaturas de nombres para el AbbreviatedDayNames de matriz y modificando la cadena de formato personalizado asignada a la LongDatePattern propiedad.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. Esto afecta a las cadenas de resultado devueltas por la "D" y cadenas de formato estándar "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, el cambio a la LongDatePattern también afecta la propiedad el FullDateTimePattern propiedad, que a su vez define la cadena de resultado devuelta por la cadena de formato estándar "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 conservar la fecha completa original y el patrón de tiempo, en el ejemplo se vuelve a asignar la cadena de formato personalizado original asignada a la FullDateTimePattern propiedad después de la LongDatePattern se modifica la propiedad.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.

Cambiar de un reloj de 12 horas en un reloj de 24 horasChanging from a 12-hour clock to a 24-hour clock

Muchas de las referencias culturales de .NET Framework, el tiempo se expresa mediante un reloj de 12 horas y un 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. En el ejemplo siguiente se define un ReplaceWith24HourClock método que reemplaza cualquier formato de hora que usa un reloj de 12 horas con un formato que utiliza un reloj 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

El ejemplo utiliza una expresión regular para modificar la cadena de formato.The example uses a regular expression to modify the format string. El patrón de expresión regular @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) se define como sigue:The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

ModeloPattern DescripciónDescription
^ Empieza la búsqueda de coincidencias en el principio de la cadena.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Repetición coincide con cero o uno de cero o más de espacio en blanco caracteres, seguido por la letra "t", uno o más veces, seguido de cero o más caracteres de espacio en blanco.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. Este grupo de captura se denomina openAMPM.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Si el openAMPM grupo tiene una coincidencia, la letra "h" uno o más coincidencias, seguido de uno o varios caracteres que no son "h" ni "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". La coincidencia termina al final de la cadena.The match ends at the end of the string. Todos los caracteres que se capturan una vez "h" se incluye en un grupo de captura denominado nonHours.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Si el openAMPM grupo no tiene una coincidencia, coincide con la letra "h" una o varias veces, seguidos de uno o varios caracteres que no son "h" ni "t", seguido de cero o más caracteres de espacio en blanco.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 último, coincide con uno o más apariciones de la letra "t".Finally, match one or more occurrences of the letter "t". Todos los caracteres capturados después "h" y antes de que los espacios en blanco y "t" se incluyen en un grupo de captura denominado nonHours.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

El nonHours grupo de captura contiene el minuto y, posiblemente, el segundo componente de una fecha y la cadena de formato de hora, junto con los símbolos de separador de hora.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. El patrón de reemplazo HH${nonHours} antepone la subcadena "HH" a estos elementos.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Mostrar y cambiar la era en una fechaDisplaying and changing the era in a date

En el ejemplo siguiente se agrega el especificador de formato personalizado "g" para el LongDatePattern propiedad de un objeto que representa las convenciones de formato de la referencia cultural 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. Esta adición afecta a las siguientes tres cadenas de formato estándar:This addition affects the following three standard format strings:

  • La cadena de formato estándar "D" (fecha larga), que se asigna directamente a la LongDatePattern propiedad.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • La "f" (completo de fecha / tiempo a corto) la cadena de formato estándar, que genera una cadena que concatena las subcadenas generadas por el LongDatePattern y ShortTimePattern propiedades.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.

  • La "F" (completo de fecha / hora larga) cadena de formato estándar, que se asigna directamente a la FullDateTimePattern propiedad.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Dado que no hemos configurado explícitamente este valor de propiedad, se genera dinámicamente mediante la concatenación del LongDatePattern y LongTimePattern propiedades.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

El ejemplo también muestra cómo cambiar el nombre de la era para una referencia cultural cuyo calendario tiene una era.The example also shows how to change the era name for a culture whose calendar has a single era. En este caso, la referencia cultural en-US usa el calendario gregoriano, que se representa mediante un GregorianCalendar objeto.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. La GregorianCalendar clase admite una era, que asigna un nombre a D.C.The GregorianCalendar class supports a single era, which it names A.D. (Anno Domini).(Anno Domini). En el ejemplo se cambia el nombre de la era de la era cristianaThe example changes the era name to C.E. (Era común) reemplazando el especificador de formato personalizado "g" en la cadena de formato que se asigna a la FullDateTimePattern propiedad con una cadena literal.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. El uso de una cadena literal es necesario, dado que normalmente devuelve el nombre de la era el GetEraName método desde datos privados de las tablas de referencia cultural suministradas por .NET Framework o el sistema operativo 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

Análisis de cadenas de fecha y horaParsing date and time strings

Análisis implica convertir la representación de cadena de una fecha y hora en un DateTime o DateTimeOffset valor.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Ambos de estos tipos incluyen el Parse, TryParse, ParseExact, y TryParseExact métodos para admitir las operaciones de análisis.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. El Parse y TryParse métodos convierten una cadena que puede tener una variedad de formatos, mientras que ParseExact y TryParseExact requieren que la cadena tiene un formato definido o formatos.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. Si se produce un error en la operación de análisis, Parse y ParseExact producir una excepción, mientras que TryParse y TryParseExact devolver false.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Utilizan los métodos de análisis implícita o explícitamente un DateTimeStyles valor de enumeración para determinar qué elementos de estilo (como espacios en blanco iniciales, finales o interna) puede estar presente en la cadena que se puede analizar y cómo interpretar la cadena analizada o comprobar si faltan 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. Si no proporciona un DateTimeStyles valor cuando se llama a la Parse o TryParse método, el valor predeterminado es DateTimeStyles.AllowWhiteSpaces, que es un estilo compuesto que incluye el DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, y DateTimeStyles.AllowInnerWhite marcas.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 el ParseExact y TryParseExact métodos, el valor predeterminado es DateTimeStyles.None; la cadena de entrada debe coincidir exactamente con una determinada fecha y hora de cadena de formato personalizado.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.

Utilizan los métodos de análisis también implícita o explícitamente un DateTimeFormatInfo objeto que define los símbolos específicos y los patrones que puede aparecer en la cadena que se puede analizar.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. Si no proporciona un DateTimeFormatInfo objeto, el DateTimeFormatInfo de objeto para la referencia cultural del subproceso actual se utiliza de forma predeterminada.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Para obtener más información sobre el análisis de cadenas de fecha y hora, vea los métodos de análisis individuales, como DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, y DateTimeOffset.TryParseExact.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.

El ejemplo siguiente ilustra la naturaleza de la referencia cultural de analizar cadenas de fecha y hora.The following example illustrates the culture-sensitive nature of parsing date and time strings. Se intenta analizar dos cadenas de fecha mediante las convenciones de la en-US, en-GB, fr-FR y referencias culturales 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. La fecha en que se interpreta como el 18/8/2014 en-US de la referencia cultural produce un FormatException excepción en los otros tres referencias culturales porque 18 se interpreta como el número del mes.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. 2/1/2015 se analiza como el segundo día del primer mes de la referencia cultural en-US, pero como el primer día del mes de segundo en las referencias culturales 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

Normalmente, se analizan cadenas de fecha y hora por dos motivos:Date and time strings are typically parsed for two reasons:

  • Convertir la entrada de usuario en un valor de fecha y hora.To convert user input into a date and time value.

  • Devolver un valor de fecha y hora; es decir, para deserializar un valor de fecha y hora en que se serializó anteriormente como una cadena.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

Las secciones siguientes tratan estas dos operaciones con mayor detalle.The following sections discuss these two operations in greater detail.

Analizar cadenas de usuarioParsing user strings

Cuando se analiza las cadenas de fecha y hora introducidos por el usuario, siempre debe crear un DateTimeFormatInfo objeto que refleja la configuración cultural del usuario, incluidas las personalizaciones que el usuario haya realizado.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. En caso contrario, el objeto de fecha y hora puede tener valores incorrectos.Otherwise, the date and time object may have incorrect values. Para obtener información acerca de cómo crear una instancia de un DateTimeFormatInfo objeto que refleje las personalizaciones culturales del usuario, consulte el DateTimeFormatInfo y dinámico de datos sección.For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

El ejemplo siguiente ilustra la diferencia entre una operación de análisis que refleja la configuración cultural del usuario y otra que no lo hace.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. En este caso, la referencia cultural predeterminada del sistema es en-US, pero el usuario ha utilizado el Panel de Control, región e idioma para cambiar el patrón de fecha corta de su valor predeterminado de "M/d/yyyy" a "aa/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". Cuando el usuario escribe una cadena que refleja la configuración de usuario y la cadena se analiza un DateTimeFormatInfo objeto que también refleja la configuración de usuario (reemplazos), la operación de análisis devuelve un resultado correcto.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. Sin embargo, cuando se analiza la cadena mediante un DateTimeFormatInfo objeto que refleja la configuración de referencia cultural en-US estándar, el método análisis, inicie una excepción una FormatException excepción porque interpreta 14 como el número del mes, no los dos últimos dígitos del año.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

Serializar y deserializar los datos de fecha y horaSerializing and deserializing date and time data

Serializar se esperan que los datos de fecha y hora de ida y vuelta; es decir, todos los serializa y deserializados valores deben ser idénticos.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Si un valor de fecha y hora representa un único momento en el tiempo, el valor deserializado debe representar el mismo momento en el tiempo, independientemente de la referencia cultural o la zona horaria del sistema en el que se restauró.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. En la ida y vuelta datos de fecha y hora correctamente, debe usar las convenciones de la referencia cultural invariable, que es devuelto por la InvariantInfo propiedad, para generar y analizar los datos.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. Las operaciones de formato y análisis nunca deben reflejar las convenciones de la referencia cultural predeterminada.The formatting and parsing operations should never reflect the conventions of the default culture. Si usa la configuración de la referencia cultural predeterminada, la portabilidad de los datos está estrictamente limitada; se puede deserializar correctamente sólo en un subproceso es idénticos a los del subproceso en el que se han serializado cuya configuración de la referencia cultural específica.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. En algunos casos, esto significa que los datos no se pueden incluso se correctamente serializar y deserializar en el mismo sistema.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Si el componente de hora de un valor de fecha y hora es significativo, también debe se convierten a UTC y serializar mediante el uso de la "o" u "r" cadena de formato estándar.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. A continuación, se pueden restaurar los datos de tiempo mediante una llamada a un método de análisis y se le pasa la cadena de formato adecuado junto con la referencia cultural invariable como el provider 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.

El ejemplo siguiente ilustra el proceso de un valor de fecha y hora de ida y vuelta.The following example illustrates the process of round-tripping a date and time value. Serializa una fecha y hora en un sistema que observa EE. UU. Hora del Pacífico y cuya referencia cultural actual es 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)

Deserializa los datos en un sistema en la zona horaria Bruselas, Copenhague, Madrid y París y cuya referencia cultural actual es 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. La fecha restaurada es nueve horas posteriores a la fecha original, que refleja el ajuste de zona horaria de ocho horas por detrás de la hora UTC a una hora por delante de 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. La fecha original y la fecha restaurada representan el mismo momento en el tiempo.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

Constructores

DateTimeFormatInfo() DateTimeFormatInfo() DateTimeFormatInfo() DateTimeFormatInfo()

Inicializa una nueva instancia de la clase DateTimeFormatInfo en la que se puede escribir y que es independiente de la referencia cultural (invariable).Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Propiedades

AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames

Obtiene o establece una matriz de una dimensión de tipo String que contiene las abreviaturas de nombres específicas de la referencia cultural de los días de la 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

Obtiene o establece una matriz de cadenas de nombres abreviados de los meses asociada al objeto DateTimeFormatInfo actual.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames

Obtiene o establece una matriz de cadenas de una dimensión que contiene abreviaturas específicas de la referencia cultural de los meses.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator AMDesignator AMDesignator AMDesignator

Obtiene o establece el designador de cadena para las horas que son "ante meridiem" (antes de mediodía).Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar Calendar Calendar Calendar

Obtiene o establece el calendario que se utilizará para la referencia cultural actual.Gets or sets the calendar to use for the current culture.

CalendarWeekRule CalendarWeekRule CalendarWeekRule CalendarWeekRule

Obtiene o establece el valor que especifica la regla que se utiliza para determinar la primera semana del calendario del año.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Obtiene un objeto DateTimeFormatInfo de solo lectura que aplica formato a los valores basándose en la referencia cultural actual.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator DateSeparator DateSeparator DateSeparator

Obtiene o establece la cadena que separa los componentes de una fecha; es decir, el año, el mes y el día.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames DayNames DayNames DayNames

Obtiene o establece una matriz de cadena de una dimensión que contiene los nombres completos específicos de la referencia cultural de los días de la semana.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

Obtiene o establece el primer día de la semana.Gets or sets the first day of the week.

FullDateTimePattern FullDateTimePattern FullDateTimePattern FullDateTimePattern

Obtiene o establece la cadena de formato personalizado para un valor de fecha larga y de hora larga.Gets or sets the custom format string for a long date and long time value.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Obtiene el objeto DateTimeFormatInfo predeterminado de solo lectura que es independiente de la referencia cultural (de todos los idiomas).Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtiene un valor que indica si el objeto DateTimeFormatInfo es de solo lectura.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern LongDatePattern LongDatePattern LongDatePattern

Obtiene o establece la cadena de formato personalizado para un valor de fecha larga.Gets or sets the custom format string for a long date value.

LongTimePattern LongTimePattern LongTimePattern LongTimePattern

Obtiene o establece la cadena de formato personalizado para un valor de hora larga.Gets or sets the custom format string for a long time value.

MonthDayPattern MonthDayPattern MonthDayPattern MonthDayPattern

Obtiene o establece la cadena de formato personalizado para un valor de mes y día.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames

Obtiene o establece una matriz de cadenas de nombres de los meses asociada al objeto DateTimeFormatInfo actual.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames MonthNames MonthNames MonthNames

Obtiene o establece una matriz de una dimensión de tipo String que contiene los nombres completos específicos de la referencia cultural de los meses.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName NativeCalendarName NativeCalendarName NativeCalendarName

Obtiene el nombre nativo del calendario asociado al objeto DateTimeFormatInfo actual.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator PMDesignator PMDesignator PMDesignator

Obtiene o establece el designador de cadena para las horas que son "post meridiem" (después de mediodía).Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern RFC1123Pattern RFC1123Pattern RFC1123Pattern

Obtiene la cadena de formato personalizado para un valor de hora basado en la especificación 1123 de Solicitudes de comentarios (RFC) del Grupo de trabajo de ingeniería de Internet (IETF).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

Obtiene o establece la cadena de formato personalizado para un valor de fecha corta.Gets or sets the custom format string for a short date value.

ShortestDayNames ShortestDayNames ShortestDayNames ShortestDayNames

Obtiene o establece una matriz de cadenas con los nombres abreviados más cortos y únicos para los días asociada al objeto DateTimeFormatInfo actual.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern ShortTimePattern ShortTimePattern ShortTimePattern

Obtiene o establece la cadena de formato personalizado para un valor de hora corta.Gets or sets the custom format string for a short time value.

SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern

Obtiene la cadena de formato personalizado para un valor de fecha y hora que se puede ordenar.Gets the custom format string for a sortable date and time value.

TimeSeparator TimeSeparator TimeSeparator TimeSeparator

Obtiene o establece la cadena que separa los componentes de una hora; es decir, la hora, los minutos y los segundos.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern

Obtiene la cadena de formato personalizado para una cadena de fecha y hora universal que se puede ordenar, como se define en ISO 8601.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern YearMonthPattern YearMonthPattern YearMonthPattern

Obtiene o establece la cadena de formato personalizado para un valor de año y mes.Gets or sets the custom format string for a year and month value.

Métodos

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

Crea una copia superficial de la colección DateTimeFormatInfo.Creates a shallow copy of the DateTimeFormatInfo.

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

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

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

Para el día de la semana especificado, devuelve su abreviatura según la referencia cultural asociada al objeto DateTimeFormatInfo actual.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)

Devuelve la cadena que contiene la abreviatura de la era especificada, si existe.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

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

Para el mes especificado, devuelve su abreviatura según la referencia cultural asociada al objeto DateTimeFormatInfo actual.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

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

Devuelve todos los modelos estándar en los que se puede aplicar formato a los valores de fecha y hora.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char)

Devuelve todos los modelos en los que se puede aplicar formato a valores de fecha y hora mediante la cadena de formato estándar especificado.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)

Para el día de la semana especificado, devuelve su nombre completo según la referencia cultural asociada al objeto DateTimeFormatInfo actual.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)

Devuelve el valor entero que representa la era especificada.Returns the integer representing the specified era.

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

Devuelve la cadena que contiene el nombre de la era especificada.Returns the string containing the name of the specified era.

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

Devuelve un objeto del tipo especificado que proporciona un servicio de formato de fecha y hora.Returns an object of the specified type that provides a date and time formatting service.

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

Sirve como la función hash predeterminada.Serves as the default hash function.

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

Devuelve el objeto DateTimeFormatInfo asociado al objeto IFormatProvider especificado.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

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

Para el mes especificado, devuelve su nombre completo según la referencia cultural asociada al objeto DateTimeFormatInfo actual.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)

Obtiene la abreviatura más corta para un día de la semana especificado asociado al objeto DateTimeFormatInfo actual.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

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

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

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

Devuelve un contenedor de DateTimeFormatInfo de solo lectura.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char)

Establece las cadenas del formato de fecha y hora personalizadas que corresponden a una cadena de formato estándar especificada.Sets the custom date and time format strings that correspond to a specified standard format string.

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

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)

Implementaciones de interfaz explícitas

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

Se aplica a

Consulte también: