DateTimeFormatInfo Clase

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
DateTimeFormatInfo
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se usa la reflexión para obtener las DateTimeFormatInfo propiedades del objeto para la referencia cultural de 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 utiliza esas cadenas para mostrar fechas con 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 valores de fecha y hora como los siguientes:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Modelos utilizados para dar formato a los valores de fecha.The patterns used to format date values.

  • Modelos utilizados para dar formato a los valores de hora.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.

  • La mañanaThe A.M. y P.M.and P.M. designadores usados en valores de hora.designators used in time values.

  • Calendario en el que se expresan las fechas.The calendar in which dates are expressed.

En esta sección:In this section:

Crear instancias de un objeto DateTimeFormatInfoInstantiating a DateTimeFormatInfo object

Un DateTimeFormatInfo objeto puede representar las convenciones de formato de la referencia cultural de todos los idiomas, una referencia cultural concreta, una referencia cultural neutra o la referencia cultural actual.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 DateTimeFormatInfo tipo de objeto.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Crear instancias de un objeto DateTimeFormatInfo para la referencia cultural de todos los idiomasInstantiating a DateTimeFormatInfo object for the invariant culture

La referencia cultural de todos los idiomas 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 un país o región de habla inglés específico.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 pueden cambiar para reflejar nuevas convenciones culturales o preferencias del usuario, los datos de la referencia cultural de todos los idiomas no cambian.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 todos los idiomas de las siguientes maneras:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

En el ejemplo siguiente se usa cada uno de estos métodos para DateTimeFormatInfo crear una instancia de un objeto que representa la referencia cultural de todos los idiomas.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      

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

Una referencia cultural específica representa un idioma que se habla en un país o región determinados.A specific culture represents a language that is spoken in a particular country/region. Por ejemplo, en-US es una referencia cultural específica que representa el idioma inglés hablado en el Estados Unidos y en-CA es una referencia cultural específica que representa el idioma inglés hablado en 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:

En el ejemplo siguiente se muestra cada una de estas formas de crear DateTimeFormatInfo una instancia de un 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

Crear 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 un idioma que es independiente de un país o región; normalmente es el elemento primario de una o varias referencias culturales específicas.A neutral culture represents a culture or language that is independent of a country/region; it is typically the parent of one or more specific cultures. Por 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 manera que crea DateTimeFormatInfo un 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 el objeto DateTimeFormatInfo de una referencia cultural neutra recuperando una referencia cultural neutra de la propiedad de CultureInfo.Parent una referencia cultural concreta y recuperando 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 primaria represente la referencia cultural DateTimeFormatInfo de todos los idiomas, el objeto devuelto es de lectura y escritura.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. En el ejemplo siguiente se muestran estas maneras de crear instancias DateTimeFormatInfo de un 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 el .NET Framework versiones 1,0 a .NET Framework 3,5.NET Framework 3.5, si se intenta recuperar DateTimeFormatInfo un objeto que refleja las convenciones de formato de una referencia cultural neutra NotSupportedException , se produce una 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 específica de la referencia cultural, ya que es independiente de un país o región específicos.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, el .NET Framework devuelve un DateTimeFormatInfo objeto que refleja las convenciones de formato de una referencia cultural concreta 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 objeto de la referencia cultural en el caso de neutra refleja las convenciones de formato de la referencia cultural DateTimeFormatInfo en-US y el objeto de 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 específica que 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 DateTimeFormatInfo para comparar las propiedades de una referencia cultural neutra con las propiedades de una referencia cultural secundaria concreta.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Considera que dos calendarios son equivalentes si son el mismo tipo de calendario y, en el caso de los calendarios GregorianCalendar.CalendarType gregorianos, si sus 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.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

Crear 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 siguientes maneras:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

En el ejemplo siguiente se usa cada uno de estos métodos para DateTimeFormatInfo crear instancias de un 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 un objeto grabable DateTimeFormatInfo que represente las convenciones de la referencia cultural del subproceso actual de 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:

En el ejemplo siguiente se muestra cada manera de crear una instancia de un DateTimeFormatInfo objeto de lectura/escritura y se IsReadOnly muestra el valor de su 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 DateTimeFormatInfo los valores de propiedad utilizados en las operaciones de formato y análisis a través de la aplicación de región y de idioma 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 elegir mostrar valores de hora larga con un reloj de 24 horas (con el formato HH: mm: SS) en lugar del reloj de 12 horas predeterminado (con el formato h:mm: SS TT).For example, a user whose culture is English (United States) might choose to display long time values using a 24-hour clock (in the format HH:mm:ss) instead of the default 12-hour clock (in the format h:mm:ss tt). Los DateTimeFormatInfo objetos recuperados de las maneras descritas anteriormente reflejan estas invalidaciones de usuario.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Si esto no es deseable, puede crear un NumberFormatInfo objeto que no refleje las invalidaciones de usuario (y también es de lectura/escritura en lugar de solo lectura) llamando CultureInfo.CultureInfo(String, Boolean) al constructor y proporcionando un valor false de para useUserOverride el 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. En el ejemplo siguiente se muestra esto para un sistema cuya referencia cultural actual es inglés (Estados Unidos) y cuyo patrón de hora larga ha cambiado con respecto al valor predeterminado de h:mm: SS TT a HH: mm: SS.The following example illustrates this for a system whose current culture is English (United States) and whose long time pattern has been changed from the default of h:mm:ss tt to HH:mm:ss.

using System;
using System.Globalization;

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

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

DateTimeFormatInfo y datos dinámicosDateTimeFormatInfo and dynamic data

Los datos específicos de la referencia cultural para dar formato a los valores de DateTimeFormatInfo fecha y hora proporcionados por la clase son dinámicos CultureInfo , al igual que los datos culturales proporcionados por la 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 los objetos que están asociados a CultureInfo objetos concretos.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 de todos los DateTimeFormatInfo idiomas y su objeto asociado son estables.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. Las preferencias culturales como el calendario preferido o los formatos de fecha y hora personalizados cambian 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 cambios 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 se puede utilizar 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 de los valores de propiedad.Cascading changes to property values. Un número de propiedades relacionadas con la referencia cultural puede cambiar en tiempo de ejecución, que, a DateTimeFormatInfo su vez, hace que los datos cambien.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 una 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 CurrentInfo la 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. Del mismo modo, el calendario de una referencia cultural puede cambiar, lo que puede DateTimeFormatInfo dar lugar a cambios en numerosos 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 a la referencia cultural del sistema actual mediante las opciones de idioma y configuración regional del 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 optar por Mostrar la fecha en un formato diferente.For example, users might choose to display the date in a different format. Si la CultureInfo.UseUserOverride propiedad se establece en true DateTimeFormatInfo , las propiedades del objeto también se recuperan 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 del usuario es incompatible con la referencia cultural asociada CultureInfo al objeto (por ejemplo, si el calendario seleccionado no es ninguno de los calendarios indicados OptionalCalendars por la propiedad), los resultados de los métodos y los valores de las propiedades no están definidas.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 que se produzcan datos incoherentes, se inicializan DateTimeFormatInfo todas las propiedades reemplazables por el usuario de un objeto 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 existe la posibilidad de incoherencia, ya que ni la creación de objetos ni el proceso de invalidación de usuario son atómicos y los valores relevantes pueden cambiar 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 debe ser muy poco frecuente.However, this situation should be extremely rare.

Puede controlar si las invalidaciones de usuario se reflejan DateTimeFormatInfo en 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. En la tabla siguiente se enumeran las formas DateTimeFormatInfo en que se puede recuperar un objeto y se indica si el objeto resultante refleja las invalidaciones de usuario.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Source de objeto CultureInfo y DateTimeFormatInfoSource of CultureInfo and DateTimeFormatInfo object Refleja las invalidaciones de usuarioReflects user overrides
PropiedadCultureInfo.CurrentCulture.DateTimeFormatCultureInfo.CurrentCulture.DateTimeFormat property Yes
PropiedadDateTimeFormatInfo.CurrentInfoDateTimeFormatInfo.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 del valor del useUserOverride parámetroDepends on value of useUserOverride parameter

A menos que haya una buena razón para hacer esto, debe respetar las invalidaciones de usuario al usar DateTimeFormatInfo el objeto en las aplicaciones cliente para dar formato y analizar la entrada del usuario o para Mostrar 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. En el caso de aplicaciones de servidor o aplicaciones desatendidas, no debería hacerlo.For server applications or unattended applications, you should not. Sin embargo, si utiliza el DateTimeFormatInfo objeto de forma explícita o implícita para conservar los datos de fecha y hora en formato de cadena, debe usar un DateTimeFormatInfo objeto que refleje las convenciones de formato de la referencia cultural de todos los idiomas, o bien especificar un cadena de formato de fecha y hora personalizado que se utiliza independientemente de la referencia cultural.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 se usa implícita o explícitamente en todas las operaciones de formato de fecha y hora.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:

Todas las operaciones de formato de fecha y hora hacen IFormatProvider uso de una implementación de.All date and time formatting operations make use of an IFormatProvider implementation. La IFormatProvider interfaz incluye un método único, IFormatProvider.GetFormat(Type).The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). A este método de devolución de Type llamada se le pasa un 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. El .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 no se proporciona explícitamente una CultureInfo CultureInfo.CurrentCulture implementaciónaunmétododeformato,seutilizaelobjetodevueltoporlapropiedadquerepresentalareferenciaculturaldelIFormatProvider 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.

En el ejemplo siguiente se muestra la relación entre IFormatProvider la interfaz y DateTimeFormatInfo la clase en las operaciones de formato.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Define una implementación personalizada IFormatProvider 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 solicita un DateTimeFormatInfo objeto, el método proporciona el 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 muestra la salida del ejemplo Decimal.ToString(IFormatProvider) , el método solicita un DateTimeFormatInfo objeto para proporcionar información de formato, mientras que String.Format(IFormatProvider, String, Object[]) el método NumberFormatInfo solicita DateTimeFormatInfo y los objetos, así ICustomFormatter como un aplicación.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 DateTimeFormatInfoFormat strings and DateTimeFormatInfo properties

El DateTimeFormatInfo objeto incluye tres tipos de propiedades que se utilizan en operaciones de formato 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:

Las cadenas con formato de fecha y hora estándar, como "d", "d", "f" y "f", son alias que se corresponden con las DateTimeFormatInfo propiedades del patrón de formato determinado.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 las cadenas con formato de fecha y hora personalizado se relacionan con cadenas o subcadenas que una operación de formato inserta en el flujo 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. En la tabla siguiente se enumeran los especificadores de formato de fecha y hora estándar DateTimeFormatInfo y personalizado, así como sus propiedades asociadas.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Para obtener más información sobre cómo usar estos especificadores de formato, vea cadenas con formato de fecha y hora estándar y cadenas con formato de fecha y hora personalizado.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 DateTimeFormatInfo corresponde a una propiedad cuyo valor es una cadena de formato de fecha y hora personalizado.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, a su vez DateTimeFormatInfo , corresponden a otras propiedades.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. En la tabla solo DateTimeFormatInfo se enumeran las propiedades para las que las cadenas de formato estándar son alias y no muestra las propiedades a las que se puede tener acceso mediante cadenas de formato personalizado asignadas a esas propiedades con 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, en la tabla solo se muestran los especificadores de formato personalizado DateTimeFormatInfo que corresponden a las 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; cadena de formato estándar)"d" (short date; standard format string) ShortDatePattern, para definir el formato global de la cadena de resultado.ShortDatePattern, to define the overall format of the result string.
"D" (fecha larga; cadena de formato estándar)"D" (long date; standard format string) LongDatePattern, para definir el formato global de la cadena de resultado.LongDatePattern, to define the overall format of the result string.
"f" (fecha completa y hora corta; cadena de formato estándar)"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" (fecha completa y hora larga; 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; 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 y hora larga; cadena de formato estándar)"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; cadena de formato estándar)"M", "m" (month/day; standard format string) MonthDayPattern, para definir el formato global de la cadena de resultado.MonthDayPattern, to define the overall format of the result string.
"O", "o" (fecha y hora de recorrido de ida y vuelta; cadena de formato estándar)"O", "o" (round-trip date/time; standard format string) Ninguno.None.
"R", "r" (RFC1123; cadena de formato estándar)"R", "r" (RFC1123; standard format string) RFC1123Pattern, para definir una cadena de resultado que se ajuste al estándar 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 van a ordenar; cadena de formato estándar)"s" (sortable date/time; standard format string) SortableDateTimePattern, para definir una cadena de resultado que se ajuste 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; cadena de formato estándar)"t" (short time; standard format string) ShortTimePattern, para definir el formato global de la cadena de resultado.ShortTimePattern, to define the overall format of the result string.
"T" (hora larga; cadena de formato estándar)"T" (long time; standard format string) LongTimePattern, para definir el formato global de la cadena de resultado.LongTimePattern, to define the overall format of the result string.
"u" (fecha y hora universal que se ordenan; cadena de formato estándar)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, para definir una cadena de resultado que se ajuste al estándar ISO 8601 para la 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; cadena de formato estándar)"U" (universal full date/time; standard format string) FullDateTimePattern, para definir el formato global de la cadena de resultado.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (año mes; cadena de formato estándar)"Y", "y" (year month; standard format string) YearMonthPattern, para definir el formato global 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) Llama al 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 abreviado del mes 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) MonthNameso MonthGenitiveNamesbien, 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) AMDesignatoro PMDesignatorbien, 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) AMDesignatoro PMDesignatorbien, 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 con formato de fecha y hora modificando las propiedades asociadas DateTimeFormatInfo de un objeto que se puede escribir.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 grabable, utilice la 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. Cree una copia de lectura/escritura de DateTimeFormatInfo un objeto cuyas convenciones de formato desee modificar.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Consulte la sección creación de instancias de un objeto DateTimeFormatInfo ).(See the Instantiating a DateTimeFormatInfo object section.)

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

  3. Use el objeto DateTimeFormatInfo personalizado que creó como argumento IFormatProvider 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 utilizar la CultureAndRegionInfoBuilder clase para definir una referencia cultural personalizada (una referencia cultural que tenga un nombre único y que complemente las referencias culturales existentes) o una referencia cultural de reemplazo (una que se utiliza en lugar de una referencia cultural concreta).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 obtener acceso a esta referencia cultural mediante programación, como CultureInfo haría con cualquier objeto admitido por el .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 tiene en cuenta la referencia cultural y no sigue un formato predefinido, puede usar una cadena de formato de fecha y hora personalizado.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 está Serializando datos de fecha y hora con el formato aaaammddhhmmss, puede generar la cadena de resultado pasando la cadena de formato personalizado al DateTime.ToString(String) método, y puede volver a convertir la cadena de resultado en un DateTime valor mediante una llamada a la función 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

En el ejemplo siguiente se 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 la propiedad asociada ShortDatePattern de la referencia cultural en-US o inglés (Estados Unidos) de su valor predeterminado de "M/d/yyyy" a "yyyy"-"mm"-"DD" y usa la cadena de formato estándar "d" para mostrar la fecha antes y después ShortDatePattern de que la propiedad sea. cambio.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 separador de fechaChanging the date separator character

En el ejemplo siguiente se cambia el carácter separador DateTimeFormatInfo de fecha de un 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. En el ejemplo se usa la cadena de formato estándar "g" para mostrar la fecha antes y DateSeparator después de cambiar 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

Cambiar las abreviaturas de nombre de día 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 muestra el nombre completo del día y el mes junto con el número del día del mes y del 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 en-US para devolver una abreviatura de nombre de día de uno o dos caracteres seguido del número de días, la abreviatura del nombre del mes y el 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. Para ello, se asignan las abreviaturas de nombre de día más cortas AbbreviatedDayNames a la matriz y se modifica la cadena de formato personalizado asignada LongDatePattern a la 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 las cadenas de formato estándar "D" y "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 en la LongDatePattern propiedad también afecta a la 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 el patrón de fecha y hora completo original, el ejemplo reasigna la cadena de formato personalizado original asignada FullDateTimePattern a la propiedad LongDatePattern después de que se modifique 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 a un reloj de 24 horasChanging from a 12-hour clock to a 24-hour clock

En el caso de muchas referencias culturales en el .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 ReplaceWith24HourClock define un método que reemplaza cualquier formato de hora que use un reloj de 12 horas con un formato que use 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

En el ejemplo se usa una expresión regular para modificar la cadena de formato.The example uses a regular expression to modify the format string. El patrón @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) de expresión regular se define de la siguiente manera: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*)? Busca una coincidencia con cero o una aparición de cero o más caracteres de espacio en blanco, seguido de la letra "t" una 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 openAMPMdenomina.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Si el openAMPM grupo tiene una coincidencia, coincide con la letra "h" una o más veces, seguida de uno o más 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 capturados después de "h" se incluyen en un nonHoursgrupo de captura denominado.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, seguidas de uno o varios caracteres que no son "h" ni "t", seguidos 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 una o más apariciones de la letra "t".Finally, match one or more occurrences of the letter "t". Todos los caracteres capturados después de "h" y antes de los espacios en blanco y "t" se incluyen en nonHoursun grupo de captura denominado.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 cadena de formato de fecha y hora personalizado, 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 HH${nonHours} de reemplazo 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 LongDatePattern " a la 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 tres cadenas de formato estándar siguientes:This addition affects the following three standard format strings:

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

  • La cadena de formato estándar "f" (fecha completa y hora corta), que genera una cadena de resultado que concatena las subcadenas generadas LongDatePattern por ShortTimePattern las propiedades y.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 cadena de formato estándar "F" (fecha completa y hora larga), que se asigna directamente FullDateTimePattern a la propiedad.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Dado que no hemos establecido explícitamente este valor de propiedad, se genera dinámicamente mediante la concatenación LongTimePattern de las LongDatePattern propiedades y.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

En el ejemplo también se muestra cómo cambiar el nombre de la era para una referencia cultural cuyo calendario tiene una sola 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 GregorianCalendar un objeto.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. La GregorianCalendar clase admite una sola era, a la que se asigna el nombre 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 a la era cristiana.The example changes the era name to C.E. (Era común) reemplazando el especificador de formato personalizado "g" en la cadena de formato asignada 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, ya que el GetEraName método suele devolver el nombre de la era a partir de los datos privados de las tablas de referencia cultural proporcionadas por el .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

El análisis implica convertir la representación de cadena de una fecha y hora DateTime en DateTimeOffset un valor o.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Ambos Parsetipos incluyen los métodos, TryParse, ParseExacty TryParseExact para admitir las operaciones de análisis.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Los Parse métodos TryParse y convierten una cadena que puede tener diversos formatos, mientras ParseExact que y TryParseExact requieren que la cadena tenga un formato o formatos definidos.The Parse and TryParse methods convert a string that can have a variety of formats, whereas ParseExact and TryParseExact require that the string have a defined format or formats. Si se produce un error en Parse la ParseExact operación de análisis, y se TryParseExact produce falseuna excepción, mientras que TryParse y devuelven.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Los métodos de análisis usan implícita o explícitamente DateTimeStyles un valor de enumeración para determinar qué elementos de estilo (como el espacio en blanco inicial, final o interior) pueden estar presentes en la cadena que se va a analizar y cómo interpretar la cadena analizada o faltan elemento.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 se proporciona un DateTimeStyles valor cuando se Parse llama al método TryParse o, el valor predeterminado DateTimeStyles.AllowWhiteSpaceses, que es un estilo compuesto que incluye DateTimeStyles.AllowLeadingWhitelas DateTimeStyles.AllowTrailingWhitemarcas, DateTimeStyles.AllowInnerWhite y.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. En el ParseExact caso TryParseExact de los métodos y, DateTimeStyles.Noneel valor predeterminado es; la cadena de entrada debe coincidir exactamente con una cadena de formato de fecha y hora personalizado determinado.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.

Los métodos de análisis también usan implícita o explícitamente DateTimeFormatInfo un objeto que define los símbolos y patrones específicos que pueden aparecer en la cadena que se va a 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 se proporciona un DateTimeFormatInfo objeto, se DateTimeFormatInfo utiliza de forma predeterminada el objeto de la referencia cultural del subproceso actual.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 cómo analizar cadenas de fecha y hora, vea los métodos de análisis DateTime.Parseindividuales DateTime.TryParse, DateTimeOffset.ParseExactcomo, DateTimeOffset.TryParseExact, y.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.

En el ejemplo siguiente se muestra la naturaleza de análisis de las cadenas de fecha y hora que tienen en cuenta la referencia cultural.The following example illustrates the culture-sensitive nature of parsing date and time strings. Intenta analizar dos cadenas de fecha mediante las convenciones de las referencias culturales en-US, en-GB, fr-FR y 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 que se interpreta como 8/18/2014 en la referencia cultural en-US produce una FormatException excepción en las otras 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. 1/2/2015 se analiza como el segundo día del primer mes de la referencia cultural en-US, pero como el primer día del segundo mes 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

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

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

  • Para realizar una operación de ida y vuelta a un valor de fecha y hora; es decir, para deserializar un valor de fecha y hora que se serializó previamente 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.

En las secciones siguientes se describen estas dos operaciones con mayor detalle.The following sections discuss these two operations in greater detail.

Analizar cadenas de usuarioParsing user strings

Al analizar cadenas de fecha y hora introducidas por el usuario, siempre debe crear una instancia DateTimeFormatInfo de un objeto que refleje la configuración cultural del usuario, incluidas las personalizaciones que haya realizado el usuario.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. De lo 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 sobre cómo crear instancias de DateTimeFormatInfo un objeto que refleje las personalizaciones culturales de usuario, vea la sección DateTimeFormatInfo and Dynamic Data .For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

En el ejemplo siguiente se muestra la diferencia entre una operación de análisis que refleja la configuración cultural del usuario y otra que no.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 usado 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 escriba una cadena que refleje la configuración de usuario y la cadena se analice mediante DateTimeFormatInfo un objeto que también refleje la configuración de usuario (invalidaciones), la operación de análisis devolverá 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 un DateTimeFormatInfo objeto que refleje la configuración cultural en-US estándar analiza la cadena, el método de análisis produce una FormatException excepción porque interpreta 14 como el número del mes, no los últimos dos 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

Serialización y deserialización de datos de fecha y horaSerializing and deserializing date and time data

Los datos serializados de fecha y hora se espera que se realicen acciones de ida y vuelta; es decir, todos los valores serializados y deserializados deberían 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. Para que los datos de fecha y hora de ida y vuelta se realicen correctamente, debe usar las convenciones de la referencia cultural de InvariantInfo todos los idiomas, devuelta por la 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 no deben reflejar nunca 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 cultural predeterminada, la portabilidad de los datos es estrictamente limitada; solo se puede deserializar correctamente en un subproceso cuya configuración específica de la referencia cultural sea idéntica a la del subproceso en el que se ha serializado.If you use default cultural settings, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose cultural-specific settings are identical to those of the thread on which it was serialized. En algunos casos, esto significa que los datos no se pueden serializar ni deserializar correctamente 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 convertirse a la hora UTC y serializarse mediante la cadena de formato estándar"o" o "r".If the time component of a date and time value is significant, it should also be converted to UTC and serialized by using the "o" or "r" standard format string. Después, los datos de hora se pueden restaurar llamando a un método de análisis y pasándole la cadena de formato adecuada junto con la referencia provider cultural de todos los idiomas como 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.

En el ejemplo siguiente se muestra el proceso de recorrido de ida y vuelta de un valor de fecha y hora.The following example illustrates the process of round-tripping a date and time value. Serializa una fecha y hora en un sistema que observa 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 de 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 de restauración es de nueve horas después de la fecha original, lo que refleja el ajuste de zona horaria de ocho horas detrás de la hora UTC a una hora antes de la hora 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. Tanto la fecha original como la fecha de restauración 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()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Equals(Object)

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

(Heredado de Object)
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)

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)

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

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)

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)

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)

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

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)

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

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

(Heredado de Object)
GetInstance(IFormatProvider)

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

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)

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

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

(Heredado de Object)
MemberwiseClone()

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

(Heredado de Object)
ReadOnly(DateTimeFormatInfo)

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

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

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

(Heredado de Object)

Implementaciones de interfaz explícitas

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Se aplica a

Consulte también: