DateTimeFormatInfo Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Proporciona información específica de la referencia cultural acerca del formato de los valores de fecha y hora.
public ref class DateTimeFormatInfo sealed : IFormatProviderpublic ref class DateTimeFormatInfo sealed : ICloneable, IFormatProviderpublic ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider, System::Runtime::Serialization::ISerializablepublic sealed class DateTimeFormatInfo : IFormatProviderpublic sealed class DateTimeFormatInfo : ICloneable, IFormatProvider[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider, System.Runtime.Serialization.ISerializable[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvidertype DateTimeFormatInfo = class
interface IFormatProvidertype DateTimeFormatInfo = class
interface ICloneable
interface IFormatProvider[<System.Serializable>]
type DateTimeFormatInfo = class
interface ICloneable
interface IFormatProvider
interface ISerializable[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type DateTimeFormatInfo = class
interface ICloneable
interface IFormatProviderPublic NotInheritable Class DateTimeFormatInfo
Implements IFormatProviderPublic NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProviderPublic NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider, ISerializable- Herencia
-
DateTimeFormatInfo
- Atributos
- Implementaciones
Ejemplos
En el ejemplo siguiente se usa la reflexión para obtener las propiedades del DateTimeFormatInfo objeto para la referencia cultural inglés (Estados Unidos). Muestra el valor de esas propiedades que contienen cadenas de formato personalizado y usa esas cadenas para mostrar fechas con formato.
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 clase contienen información específica de la DateTimeFormatInfo referencia cultural para dar formato o analizar valores de fecha y hora, como los siguientes:
Patrones usados para dar formato a los valores de fecha.
Patrones usados para dar formato a los valores de hora.
Nombres de los días de la semana.
Nombres de los meses del año.
Los designadores A.M. y P.M. usados en valores de tiempo.
Calendario en el que se expresan las fechas.
En esta sección:
Creación de instancias de un objeto DateTimeFormatInfo
Un DateTimeFormatInfo objeto puede representar las convenciones de formato de la referencia cultural invariable, una referencia cultural específica, una referencia cultural neutra o la referencia cultural actual. En esta sección se describe cómo crear instancias de cada tipo de DateTimeFormatInfo objeto.
Creación de instancias de un objeto DateTimeFormatInfo para la referencia cultural invariable
La referencia cultural invariable representa una referencia cultural que no distingue la referencia cultural. Se basa en el idioma inglés, pero no en ningún país o región específicos de habla inglesa. Aunque los datos de referencias culturales específicas pueden ser dinámicos y pueden cambiar para reflejar nuevas convenciones culturales o preferencias de usuario, los datos de la referencia cultural invariable no cambian. Puede crear instancias de un DateTimeFormatInfo objeto que represente las convenciones de formato de la referencia cultural invariable de las maneras siguientes:
Recuperando el valor de la InvariantInfo propiedad . El objeto devuelto DateTimeFormatInfo es de solo lectura.
Llamando al constructor sin parámetros DateTimeFormatInfo . El objeto devuelto DateTimeFormatInfo es de lectura y escritura.
Recuperando el valor de la DateTimeFormat propiedad del CultureInfo objeto devuelto por la CultureInfo.InvariantCulture propiedad . El objeto devuelto DateTimeFormatInfo es de solo lectura.
En el ejemplo siguiente se usa cada uno de estos métodos para crear instancias de un DateTimeFormatInfo objeto que representa la referencia cultural invariable. A continuación, indica si el objeto es de solo lectura.
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
Creación de instancias de un objeto DateTimeFormatInfo para una referencia cultural específica
Una referencia cultural específica representa un idioma que se habla en un país o región determinados. 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á. Puede crear instancias de un DateTimeFormatInfo objeto que represente las convenciones de formato de una referencia cultural específica de las siguientes maneras:
Llamando al CultureInfo.GetCultureInfo(String) método y recuperando el valor de la propiedad del CultureInfo.DateTimeFormat objeto devueltoCultureInfo. El objeto devuelto DateTimeFormatInfo es de solo lectura.
Al pasar el método estático GetInstance un CultureInfo objeto que representa la referencia cultural cuyo DateTimeFormatInfo objeto desea recuperar. El objeto devuelto DateTimeFormatInfo es de lectura y escritura.
Llamando al método estático CultureInfo.CreateSpecificCulture y recuperando el valor de la propiedad del CultureInfo.DateTimeFormat objeto devueltoCultureInfo. El objeto devuelto DateTimeFormatInfo es de lectura y escritura.
Llamando al CultureInfo.CultureInfo constructor de clase y recuperando el valor de la propiedad del CultureInfo.DateTimeFormat objeto devueltoCultureInfo. El objeto devuelto DateTimeFormatInfo es de lectura y escritura.
En el ejemplo siguiente se muestra cada una de estas formas de crear una instancia de un DateTimeFormatInfo objeto e indica si el objeto resultante es de solo lectura.
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
Creación de instancias de un objeto DateTimeFormatInfo para una referencia cultural neutra
Una referencia cultural neutral 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. Por ejemplo, Fr es una referencia cultural neutra para el idioma francés y el elemento primario de la referencia cultural fr-FR. Puede crear una instancia de un DateTimeFormatInfo objeto que represente las convenciones de formato de una referencia cultural neutra de las mismas maneras en que cree un DateTimeFormatInfo objeto que represente las convenciones de formato de una referencia cultural específica. Además, puede recuperar el objeto de DateTimeFormatInfo una referencia cultural neutra recuperando una referencia cultural neutra de la propiedad de CultureInfo.Parent una referencia cultural específica y recuperando el DateTimeFormatInfo objeto devuelto por su CultureInfo.DateTimeFormat propiedad. A menos que la referencia cultural primaria represente la referencia cultural invariable, el objeto devuelto DateTimeFormatInfo es de lectura y escritura. En el ejemplo siguiente se muestran estas formas de crear instancias de un DateTimeFormatInfo objeto que representa una referencia cultural neutra.
System.Globalization.CultureInfo specific, neutral;
System.Globalization.DateTimeFormatInfo dtfi;
// Instantiate a culture by creating a specific culture and using its Parent property.
specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR");
neutral = specific.Parent;
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);
dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);
// Instantiate a neutral culture using the CultureInfo constructor.
neutral = new System.Globalization.CultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly);
// Instantiate a culture using CreateSpecificCulture.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly);
// Retrieve a culture by calling the GetCultureInfo method.
neutral = System.Globalization.CultureInfo.GetCultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly);
// Instantiate a DateTimeFormatInfo object by calling GetInstance.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral);
Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly);
// The example displays the following output:
// fr from Parent property: False
// fr from Parent property: False
// fr from CultureInfo constructor: False
// fr-FR from CreateSpecificCulture: False
// fr from GetCultureInfo: True
// fr-FR from GetInstance: False
Dim specific, neutral As System.Globalization.CultureInfo
Dim dtfi As System.Globalization.DateTimeFormatInfo
' Instantiate a culture by creating a specific culture and using its Parent property.
specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR")
neutral = specific.Parent
dtfi = neutral.DateTimeFormat
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly)
dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly)
' Instantiate a neutral culture using the CultureInfo constructor.
neutral = New System.Globalization.CultureInfo("fr")
dtfi = neutral.DateTimeFormat
Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly)
' Instantiate a culture using CreateSpecificCulture.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
dtfi = neutral.DateTimeFormat
Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly)
' Retrieve a culture by calling the GetCultureInfo method.
neutral = System.Globalization.CultureInfo.GetCultureInfo("fr")
dtfi = neutral.DateTimeFormat
Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly)
' Instantiate a DateTimeFormatInfo object by calling GetInstance.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral)
Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly)
' The example displays the following output:
' fr from Parent property: False
' fr from Parent property: False
' fr from CultureInfo constructor: False
' fr-FR from CreateSpecificCulture: False
' fr from GetCultureInfo: True
' fr-FR from GetInstance: False
Nota
En las versiones 1.0 de .NET Framework a .NET Framework 3.5, al intentar recuperar un DateTimeFormatInfo objeto que refleja las convenciones de formato de una referencia cultural neutral, se produce una NotSupportedException excepción.
Sin embargo, una referencia cultural neutral 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. En lugar de rellenar el DateTimeFormatInfo objeto con valores genéricos, .NET Framework devuelve un DateTimeFormatInfo objeto que refleja las convenciones de formato de una referencia cultural específica que es un elemento secundario de la referencia cultural neutra. Por ejemplo, el DateTimeFormatInfo objeto de la referencia cultural neutra refleja las convenciones de formato de la referencia cultural en-US y el DateTimeFormatInfo objeto de la referencia cultural fr refleja las convenciones de formato de la referencia cultural fr-FR.
Puede usar código como el siguiente para determinar qué convenciones de formato de referencia cultural específicas representa una referencia cultural neutra. En el ejemplo se usa la reflexión para comparar las DateTimeFormatInfo propiedades de una referencia cultural neutra con las propiedades de una referencia cultural secundaria específica. Considera que dos calendarios son equivalentes si son del mismo tipo de calendario y, para los calendarios gregorianos, si sus GregorianCalendar.CalendarType propiedades tienen valores idénticos.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
public class Example
{
public static void Main()
{
// Get all the neutral cultures
List<String> names = new List<String>();
Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
culture => names.Add(culture.Name));
names.Sort();
foreach (var name in names) {
// Ignore the invariant culture.
if (name == "") continue;
ListSimilarChildCultures(name);
}
}
private static void ListSimilarChildCultures(String name)
{
// Create the neutral DateTimeFormatInfo object.
DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo(name).DateTimeFormat;
// Retrieve all specific cultures of the neutral culture.
CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
// Create an array of DateTimeFormatInfo properties
PropertyInfo[] properties = typeof(DateTimeFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
bool hasOneMatch = false;
foreach (var ci in cultures) {
bool match = true;
// Get the DateTimeFormatInfo for a specific culture.
DateTimeFormatInfo specificDtfi = ci.DateTimeFormat;
// Compare the property values of the two.
foreach (var prop in properties) {
// We're not interested in the value of IsReadOnly.
if (prop.Name == "IsReadOnly") continue;
// For arrays, iterate the individual elements to see if they are the same.
if (prop.PropertyType.IsArray) {
IList nList = (IList) prop.GetValue(dtfi, null);
IList sList = (IList) prop.GetValue(specificDtfi, null);
if (nList.Count != sList.Count) {
match = false;
Console.WriteLine(" Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name);
break;
}
for (int ctr = 0; ctr < nList.Count; ctr++) {
if (! nList[ctr].Equals(sList[ctr])) {
match = false;
Console.WriteLine(" {0} value different for {1} and {2}", prop.Name, name, ci.Name);
break;
}
}
if (! match) break;
}
// Get non-array values.
else {
Object specificValue = prop.GetValue(specificDtfi);
Object neutralValue = prop.GetValue(dtfi);
// Handle comparison of Calendar objects.
if (prop.Name == "Calendar") {
// The cultures have a different calendar type.
if (specificValue.ToString() != neutralValue.ToString()) {
Console.WriteLine(" Different calendar types for {0} and {1}", name, ci.Name);
match = false;
break;
}
if (specificValue is GregorianCalendar) {
if (((GregorianCalendar) specificValue).CalendarType != ((GregorianCalendar) neutralValue).CalendarType) {
Console.WriteLine(" Different Gregorian calendar types for {0} and {1}", name, ci.Name);
match = false;
break;
}
}
}
else if (! specificValue.Equals(neutralValue)) {
match = false;
Console.WriteLine(" Different {0} values for {1} and {2}", prop.Name, name, ci.Name);
break;
}
}
}
if (match) {
Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'",
name, ci.Name);
hasOneMatch = true;
}
}
if (! hasOneMatch)
Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name);
Console.WriteLine();
}
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection
Module Example
Public Sub Main()
' Get all the neutral cultures
Dim names As New List(Of String)
Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
Sub(culture) names.Add(culture.Name))
names.Sort()
For Each name In names
' Ignore the invariant culture.
If name = "" Then Continue For
ListSimilarChildCultures(name)
Next
End Sub
Private Sub ListSimilarChildCultures(name As String)
' Create the neutral DateTimeFormatInfo object.
Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo(name).DateTimeFormat
' Retrieve all specific cultures of the neutral culture.
Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
' Create an array of DateTimeFormatInfo properties
Dim properties() As PropertyInfo = GetType(DateTimeFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
Dim hasOneMatch As Boolean = False
For Each ci In cultures
Dim match As Boolean = True
' Get the DateTimeFormatInfo for a specific culture.
Dim specificDtfi As DateTimeFormatInfo = ci.DateTimeFormat
' Compare the property values of the two.
For Each prop In properties
' We're not interested in the value of IsReadOnly.
If prop.Name = "IsReadOnly" Then Continue For
' For arrays, iterate the individual elements to see if they are the same.
If prop.PropertyType.IsArray Then
Dim nList As IList = CType(prop.GetValue(dtfi, Nothing), IList)
Dim sList As IList = CType(prop.GetValue(specificDtfi, Nothing), IList)
If nList.Count <> sList.Count Then
match = false
Console.WriteLine(" Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name)
Exit For
End If
For ctr As Integer = 0 To nList.Count - 1
If Not nList(ctr).Equals(sList(ctr))
match = false
Console.WriteLine(" {0} value different for {1} and {2}", prop.Name, name, ci.Name)
Exit For
End If
Next
If Not match Then Exit For
' Get non-array values.
Else
Dim specificValue As Object = prop.GetValue(specificDtfi)
Dim neutralValue As Object = prop.GetValue(dtfi)
' Handle comparison of Calendar objects.
If prop.Name = "Calendar" Then
' The cultures have a different calendar type.
If specificValue.ToString() <> neutralValue.ToString() Then
Console.WriteLine(" Different calendar types for {0} and {1}", name, ci.Name)
match = False
Exit For
End If
If TypeOf specificValue Is GregorianCalendar Then
If CType(specificValue, GregorianCalendar).CalendarType <> CType(neutralValue, GregorianCalendar).CalendarType Then
Console.WriteLine(" Different Gregorian calendar types for {0} and {1}", name, ci.Name)
match = False
Exit For
End If
End If
Else If Not specificValue.Equals(neutralValue) Then
match = false
Console.WriteLine(" Different {0} values for {1} and {2}", prop.Name, name, ci.Name)
Exit For
End If
End If
Next
If match Then
Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'",
name, ci.Name)
hasOneMatch = True
End If
Next
If Not hasOneMatch Then
Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name)
End If
Console.WriteLine()
End Sub
End Module
Creación de instancias de un objeto DateTimeFormatInfo para la referencia cultural actual
Puede crear instancias de un DateTimeFormatInfo objeto que represente las convenciones de formato de la referencia cultural actual de las siguientes maneras:
Recuperando el valor de la CurrentInfo propiedad . El objeto devuelto DateTimeFormatInfo es de solo lectura.
Recuperando el valor de la DateTimeFormat propiedad del CultureInfo objeto devuelto por la CultureInfo.CurrentCulture propiedad . El objeto devuelto DateTimeFormatInfo es de solo lectura.
Llamando al GetInstance método con un CultureInfo objeto que representa la referencia cultural actual. El objeto devuelto DateTimeFormatInfo es de solo lectura.
En el ejemplo siguiente se usa cada uno de estos métodos para crear instancias de un DateTimeFormatInfo objeto que representa las convenciones de formato de la referencia cultural actual. A continuación, indica si el objeto es de solo lectura.
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 actual de una de estas maneras:
Recuperando un DateTimeFormatInfo objeto de cualquiera de las tres formas anteriores y llamando al Clone método en el objeto devuelto DateTimeFormatInfo . Esto crea una copia del objeto original DateTimeFormatInfo , excepto que su IsReadOnly propiedad es
false.Llamando al CultureInfo.CreateSpecificCulture método para crear un CultureInfo objeto que represente la referencia cultural actual y, a continuación, use su CultureInfo.DateTimeFormat propiedad para recuperar el DateTimeFormatInfo objeto.
En el ejemplo siguiente se muestra cada forma de crear una instancia de un objeto de lectura y escritura DateTimeFormatInfo y se muestra el valor de su IsReadOnly propiedad.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
DateTimeFormatInfo current1 = DateTimeFormatInfo.CurrentInfo;
current1 = (DateTimeFormatInfo) current1.Clone();
Console.WriteLine(current1.IsReadOnly);
CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
DateTimeFormatInfo current2 = culture2.DateTimeFormat;
Console.WriteLine(current2.IsReadOnly);
}
}
// The example displays the following output:
// False
// False
Imports System.Globalization
Module Example
Public Sub Main()
Dim current1 As DateTimeFormatInfo = DateTimeFormatInfo.CurrentInfo
current1 = CType(current1.Clone(), DateTimeFormatInfo)
Console.WriteLine(current1.IsReadOnly)
Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
Dim current2 As DateTimeFormatInfo = culture2.DateTimeFormat
Console.WriteLine(current2.IsReadOnly)
End Sub
End Module
' The example displays the following output:
' False
' False
En Windows, el usuario puede invalidar algunos de los valores de propiedad usados en las DateTimeFormatInfo operaciones de formato y análisis a través de la aplicación Region and Language en Panel de control. Por ejemplo, un usuario cuya referencia cultural es inglés (Estados Unidos) podría optar por mostrar valores de tiempo largos con un reloj de 24 horas (con el formato HH:mm:ss) en lugar del reloj predeterminado de 12 horas (con el formato h:mm:ss tt). Los DateTimeFormatInfo objetos recuperados de las maneras descritas anteriormente reflejan estas invalidaciones de usuario. Si esto no es deseable, puede crear un NumberFormatInfo objeto que no refleje las invalidaciones de usuario (y también es de lectura y escritura en lugar de solo lectura) llamando al CultureInfo.CultureInfo(String, Boolean) constructor y proporcionando un valor de false para el useUserOverride argumento. En el ejemplo siguiente se muestra esto para un sistema cuya referencia cultural actual es inglés (Estados Unidos) y cuyo patrón de tiempo largo se ha cambiado del valor predeterminado de h:mm:ss tt a 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
Datos dinámicos y DateTimeFormatInfo
Los datos específicos de la referencia cultural para dar formato a los valores de fecha y hora proporcionados por la DateTimeFormatInfo clase son dinámicos, al igual que los datos culturales proporcionados por la CultureInfo clase. No debe realizar ninguna suposición sobre la estabilidad de los valores de DateTimeFormatInfo los objetos asociados a objetos concretos CultureInfo . Solo los datos proporcionados por la referencia cultural invariable y su objeto asociado DateTimeFormatInfo son estables. Otros datos pueden cambiar entre sesiones de aplicación o incluso mientras se ejecuta la aplicación. Hay cuatro orígenes principales de cambio:
Actualizaciones del sistema. Las preferencias culturales, como el calendario preferido o los formatos de fecha y hora habituales cambian con el tiempo. Cuando esto sucede, Windows Update incluye cambios en el valor de propiedad DateTimeFormatInfo de una referencia cultural determinada.
Referencias culturales de reemplazo. La CultureAndRegionInfoBuilder clase se puede usar para reemplazar los datos de una referencia cultural existente.
Cambios en cascada en los valores de propiedad. Varias propiedades relacionadas con la referencia cultural pueden cambiar en tiempo de ejecución, lo que, a su vez, hace DateTimeFormatInfo que los datos cambien. Por ejemplo, la referencia cultural actual se puede cambiar mediante programación o a través de la acción del usuario. Cuando esto sucede, el DateTimeFormatInfo objeto devuelto por la CurrentInfo propiedad cambia a un objeto asociado a la referencia cultural actual. Del mismo modo, el calendario de una referencia cultural puede cambiar, lo que puede dar lugar a cambios en numerosos DateTimeFormatInfo valores de propiedad.
Preferencias del usuario. Los usuarios de la aplicación pueden optar por invalidar algunos de los valores asociados a la referencia cultural del sistema actual a través de las opciones regionales y de idioma de Panel de control. Por ejemplo, los usuarios pueden optar por mostrar la fecha en un formato diferente. Si la CultureInfo.UseUserOverride propiedad se establece
trueen , las propiedades del DateTimeFormatInfo objeto también se recuperan de la configuración del usuario. Si la configuración de usuario no es compatible con la referencia cultural asociada al CultureInfo objeto (por ejemplo, si el calendario seleccionado no es uno de los calendarios indicados por la OptionalCalendars propiedad ), los resultados de los métodos y los valores de las propiedades no están definidos.
Para minimizar la posibilidad de datos incoherentes, todas las propiedades reemplazables por el usuario de un DateTimeFormatInfo objeto se inicializan cuando se crea el objeto. Todavía existe la posibilidad de incoherencia, ya que ni la creación de objetos ni el proceso de invalidación del usuario son atómicas y los valores pertinentes pueden cambiar durante la creación de objetos. Sin embargo, esta situación debe ser extremadamente rara.
Puede controlar si las invalidaciones de usuario se reflejan en DateTimeFormatInfo objetos que representan la misma referencia cultural que la referencia cultural del sistema. En la tabla siguiente se enumeran las formas en que se puede recuperar un DateTimeFormatInfo objeto e indica si el objeto resultante refleja las invalidaciones del usuario.
| Origen del objeto CultureInfo y DateTimeFormatInfo | Refleja las invalidaciones de usuario |
|---|---|
PropiedadCultureInfo.CurrentCulture.DateTimeFormat |
Sí |
| PropiedadDateTimeFormatInfo.CurrentInfo | Sí |
| Método CultureInfo.CreateSpecificCulture | Sí |
| Método CultureInfo.GetCultureInfo | No |
| Constructor CultureInfo.CultureInfo(String) | Sí |
| Constructor CultureInfo.CultureInfo(String, Boolean) | Depende del valor del useUserOverride parámetro |
A menos que haya un motivo atractivo para hacerlo de lo contrario, debe respetar las invalidaciones de usuario al usar el DateTimeFormatInfo objeto en las aplicaciones cliente para dar formato y analizar la entrada del usuario o para mostrar los datos. En el caso de las aplicaciones de servidor o las aplicaciones desatendidas, no debe. Sin embargo, si usa el DateTimeFormatInfo objeto explícita o implícitamente para conservar datos de fecha y hora en forma de cadena, debe usar un DateTimeFormatInfo objeto que refleje las convenciones de formato de la referencia cultural invariable, o bien debe especificar una cadena de formato de fecha y hora personalizada que use independientemente de la referencia cultural.
Aplicar formato a fechas y horas
Un DateTimeFormatInfo objeto se usa implícita o explícitamente en todas las operaciones de formato de fecha y hora. Estas incluyen llamadas a los métodos siguientes:
Todos los métodos de formato de fecha y hora, como DateTime.ToString() y DateTimeOffset.ToString(String).
El método de formato compuesto principal, que es String.Format.
Otros métodos de formato compuesto, como Console.WriteLine(String, Object[]) y StringBuilder.AppendFormat(String, Object[]).
Todas las operaciones de formato de fecha y hora usan una IFormatProvider implementación. La IFormatProvider interfaz incluye un único método, IFormatProvider.GetFormat(Type). Este método de devolución de llamada se pasa a un Type objeto que representa el tipo necesario para proporcionar información de formato. El método devuelve una instancia de ese tipo o null si no puede proporcionar una instancia del tipo . .NET Framework incluye dos IFormatProvider implementaciones para dar formato a fechas y horas:
Clase CultureInfo , que representa una referencia cultural específica (o un idioma específico en un país o región específicos). En una operación de formato de fecha y hora, el CultureInfo.GetFormat método devuelve el DateTimeFormatInfo objeto asociado a su CultureInfo.DateTimeFormat propiedad .
La DateTimeFormatInfo clase , que proporciona información sobre las convenciones de formato de su referencia cultural asociada. El DateTimeFormatInfo.GetFormat método devuelve una instancia de sí misma.
Si una IFormatProvider implementación no se proporciona explícitamente a un método de formato, se usa el CultureInfo objeto devuelto por la CultureInfo.CurrentCulture propiedad que representa la referencia cultural actual.
En el ejemplo siguiente se muestra la relación entre la IFormatProvider interfaz y la DateTimeFormatInfo clase en las operaciones de formato. Define una implementación personalizada IFormatProvider cuyo GetFormat método muestra el tipo del objeto solicitado por la operación de formato. Si solicita un DateTimeFormatInfo objeto , el método proporciona el DateTimeFormatInfo objeto para la referencia cultural actual. Como se muestra en la salida del ejemplo, el Decimal.ToString(IFormatProvider) método solicita un DateTimeFormatInfo objeto para proporcionar información de formato, mientras que el String.Format(IFormatProvider, String, Object[]) método solicita NumberFormatInfo y DateTimeFormatInfo objetos, así como una ICustomFormatter implementación.
using System;
using System.Globalization;
public class CurrentCultureFormatProvider : IFormatProvider
{
public Object GetFormat(Type formatType)
{
Console.WriteLine("Requesting an object of type {0}",
formatType.Name);
if (formatType == typeof(NumberFormatInfo))
return NumberFormatInfo.CurrentInfo;
else if (formatType == typeof(DateTimeFormatInfo))
return DateTimeFormatInfo.CurrentInfo;
else
return null;
}
}
public class Example
{
public static void Main()
{
DateTime dateValue = new DateTime(2013, 5, 28, 13, 30, 0);
string value = dateValue.ToString("F", new CurrentCultureFormatProvider());
Console.WriteLine(value);
Console.WriteLine();
string composite = String.Format(new CurrentCultureFormatProvider(),
"Date: {0:d} Amount: {1:C} Description: {2}",
dateValue, 1264.03m, "Service Charge");
Console.WriteLine(composite);
Console.WriteLine();
}
}
// The example displays output like the following:
// Requesting an object of type DateTimeFormatInfo
// Tuesday, May 28, 2013 1:30:00 PM
//
// Requesting an object of type ICustomFormatter
// Requesting an object of type DateTimeFormatInfo
// Requesting an object of type NumberFormatInfo
// Date: 5/28/2013 Amount: $1,264.03 Description: Service Charge
Imports System.Globalization
Public Class CurrentCultureFormatProvider : Implements IFormatProvider
Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
Console.WriteLine("Requesting an object of type {0}",
formatType.Name)
If formatType Is GetType(NumberFormatInfo) Then
Return NumberFormatInfo.CurrentInfo
Else If formatType Is GetType(DateTimeFormatInfo) Then
Return DateTimeFormatInfo.CurrentInfo
Else
Return Nothing
End If
End Function
End Class
Module Example
Public Sub Main()
Dim dateValue As New Date(2013, 05, 28, 13, 30, 0)
Dim value As String = dateValue.ToString("F", New CurrentCultureFormatProvider())
Console.WriteLine(value)
Console.WriteLine()
Dim composite As String = String.Format(New CurrentCultureFormatProvider,
"Date: {0:d} Amount: {1:C} Description: {2}",
dateValue, 1264.03d, "Service Charge")
Console.WriteLine(composite)
Console.WriteLine()
End Sub
End Module
' The example displays output like the following:
' Requesting an object of type DateTimeFormatInfo
' Tuesday, May 28, 2013 1:30:00 PM
'
' Requesting an object of type ICustomFormatter
' Requesting an object of type DateTimeFormatInfo
' Requesting an object of type NumberFormatInfo
' Date: 5/28/2013 Amount: $1,264.03 Description: Service Charge
Cadenas de formato y propiedades DateTimeFormatInfo
El DateTimeFormatInfo objeto incluye tres tipos de propiedades que se usan en las operaciones de formato con valores de fecha y hora:
Propiedades relacionadas con el calendario. Las propiedades como AbbreviatedDayNames, AbbreviatedMonthNames, DayNamesy MonthNames, están asociadas al calendario utilizado por la referencia cultural, que se define mediante la Calendar propiedad . Estas propiedades se usan para formatos de fecha y hora largos.
Propiedades que generan una cadena de resultado definida por estándares. Las RFC1123Patternpropiedades , SortableDateTimePatterny UniversalSortableDateTimePattern contienen cadenas de formato personalizadas que generan cadenas de resultado definidas por estándares internacionales. Estas propiedades son de solo lectura y no se pueden modificar.
Propiedades que definen cadenas de resultados que distinguen referencias culturales. Algunas propiedades, como FullDateTimePattern y ShortDatePattern, contienen cadenas de formato personalizado que especifican el formato de la cadena de resultado. Otros, como AMDesignator, DateSeparator, PMDesignatory TimeSeparator, definen símbolos o subcadenas que distinguen referencias culturales que se pueden incluir en una cadena de resultado.
Las cadenas de formato de fecha y hora estándar, como "d", "D", "f" y "F", son alias que corresponden a propiedades de patrón de formato concretas DateTimeFormatInfo . La mayoría de las cadenas de formato de fecha y hora personalizadas están relacionadas con cadenas o subcadenas que una operación de formato inserta en la secuencia de resultados. En la tabla siguiente se enumeran los especificadores de formato de fecha y hora estándar y personalizados y sus propiedades asociadas DateTimeFormatInfo . Para obtener más información sobre cómo usar estos especificadores de formato, vea Cadenas de formato de fecha y hora estándar y cadenas de formato de fecha y hora personalizadas. Tenga en cuenta que cada cadena de formato estándar corresponde a una DateTimeFormatInfo propiedad cuyo valor es una cadena de formato de fecha y hora personalizada. Los especificadores individuales de esta cadena de formato personalizado a su vez corresponden a otras DateTimeFormatInfo propiedades. La tabla muestra solo las DateTimeFormatInfo propiedades para las que las cadenas de formato estándar son alias y no enumera las propiedades a las que pueden tener acceso las cadenas de formato personalizado asignadas a esas propiedades con alias. Además, la tabla muestra solo especificadores de formato personalizado que corresponden a DateTimeFormatInfo propiedades.
| Especificador de formato | Propiedades asociadas |
|---|---|
| "d" (fecha corta; cadena de formato estándar) | ShortDatePattern, para definir el formato general de la cadena de resultado. |
| "D" (fecha larga; cadena de formato estándar) | LongDatePattern, para definir el formato general de la cadena de resultado. |
| "f" (fecha completa/hora corta; cadena de formato estándar) | LongDatePattern, para definir el formato del componente de fecha de la cadena de resultado. ShortTimePattern, para definir el formato del componente de hora de la cadena de resultado. |
| "F" (fecha completa/hora larga; cadena de formato estándar) | LongDatePattern, para definir el formato del componente de fecha de la cadena de resultado. LongTimePattern, para definir el formato del componente de hora de la cadena de resultado. |
| "g" (fecha general/ hora corta; cadena de formato estándar) | ShortDatePattern, para definir el formato del componente de fecha de la cadena de resultado. ShortTimePattern, para definir el formato del componente de hora de la cadena de resultado. |
| "G" (fecha general/hora larga; cadena de formato estándar) | ShortDatePattern, para definir el formato del componente de fecha de la cadena de resultado. LongTimePattern, para definir el formato del componente de hora de la cadena de resultado. |
| "M", "m" (mes/día; cadena de formato estándar) | MonthDayPattern, para definir el formato general de la cadena de resultado. |
| "O", "o" (fecha y hora de ida y vuelta; cadena de formato estándar) | Ninguno. |
| "R", "r" (RFC1123; cadena de formato estándar) | RFC1123Pattern, para definir una cadena de resultado que se ajuste al estándar RFC 1123. La propiedad es de solo lectura. |
| "s" (fecha y hora ordenables; cadena de formato estándar) | SortableDateTimePattern, para definir una cadena de resultado que se ajuste al estándar ISO 8601. La propiedad es de solo lectura. |
| "t" (breve tiempo; cadena de formato estándar) | ShortTimePattern, para definir el formato general de la cadena de resultado. |
| "T" (tiempo largo; cadena de formato estándar) | LongTimePattern, para definir el formato general de la cadena de resultado. |
| "u" (fecha y hora ordenable universal; cadena de formato estándar) | UniversalSortableDateTimePattern, para definir una cadena de resultado que se ajuste al estándar ISO 8601 para la hora universal coordinada. La propiedad es de solo lectura. |
| "U" (fecha y hora completa universal; cadena de formato estándar) | FullDateTimePattern, para definir el formato general de la cadena de resultado. |
| "Y", "y" (mes del año; cadena de formato estándar) | YearMonthPattern, para definir el formato general de la cadena de resultado. |
| "ddd" (especificador de formato personalizado) | AbbreviatedDayNames, para incluir el nombre abreviado del día de la semana en la cadena de resultado. |
| "g", "gg" (especificador de formato personalizado) | Llama al GetEraName método para insertar el nombre de era en la cadena de resultado. |
| "MMM" (especificador de formato personalizado) | AbbreviatedMonthNames, para incluir el nombre abreviado del mes en la cadena de resultado. |
| "MMMM" (especificador de formato personalizado) | MonthNames o MonthGenitiveNames, para incluir el nombre completo del mes en la cadena de resultado. |
| "t" (especificador de formato personalizado) | AMDesignator o PMDesignator, para incluir el primer carácter del designador AM/PM en la cadena de resultado. |
| "tt" (especificador de formato personalizado) | AMDesignator o PMDesignator, para incluir el designador completo de AM/PM en la cadena de resultado. |
| ":" (especificador de formato personalizado) | TimeSeparator, para incluir el separador de hora en la cadena de resultado. |
| "/" (especificador de formato personalizado) | DateSeparator, para incluir el separador de fecha en la cadena de resultado. |
Modificación de las propiedades DateTimeFormatInfo
Puede cambiar la cadena de resultado generada por cadenas de formato de fecha y hora modificando las propiedades asociadas de un objeto grabable DateTimeFormatInfo . Para determinar si se puede escribir un DateTimeFormatInfo objeto, use la IsReadOnly propiedad . Para personalizar un DateTimeFormatInfo objeto de esta manera:
Cree una copia de lectura y escritura de un DateTimeFormatInfo objeto cuyas convenciones de formato desee modificar. (Consulte la sección Creación de instancias de un objeto DateTimeFormatInfo ).
Modifique la propiedad o las propiedades que se usan para generar la cadena de resultado deseada. (Para obtener información sobre cómo los métodos de formato usan DateTimeFormatInfo propiedades para definir cadenas de resultado, vea la sección anterior, Cadenas de formato y propiedades DateTimeFormatInfo).
Use el objeto personalizado DateTimeFormatInfo que creó como IFormatProvider argumento en llamadas a métodos de formato.
Hay otras dos maneras de cambiar el formato de una cadena de resultado:
Puede usar la CultureAndRegionInfoBuilder clase para definir una referencia cultural personalizada (una referencia cultural que tiene un nombre único y que complementa las referencias culturales existentes) o una referencia cultural de reemplazo (una que se usa en lugar de una referencia cultural específica). Puede guardar y acceder a esta referencia cultural mediante programación, como haría con cualquier CultureInfo objeto compatible con .NET Framework.
Si la cadena de resultado no distingue la referencia cultural y no sigue un formato predefinido, puede usar una cadena de formato de fecha y hora personalizada. Por ejemplo, si va a serializar 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 convertir la cadena de resultado en un DateTime valor llamando al DateTime.ParseExact método .
Cambio del patrón de fecha corta
En el ejemplo siguiente se cambia el formato de una cadena de resultado generada por la cadena de formato estándar "d" (fecha corta). Cambia la propiedad asociada ShortDatePattern para la referencia cultural en-US o inglés (Estados Unidos) de su valor predeterminado de "M/d/aaaa" a "aaaa"-"MM"-"dd" y usa la cadena de formato estándar "d" para mostrar la fecha antes y después de que se cambie la ShortDatePattern propiedad.
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 fecha
En el ejemplo siguiente se cambia el carácter separador de fecha de un DateTimeFormatInfo objeto que representa las convenciones de formato de la referencia cultural fr-FR. En el ejemplo se usa la cadena de formato estándar "g" para mostrar la fecha antes y después de cambiar la DateSeparator propiedad.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
DateTime dateValue = new DateTime(2013, 08, 28);
CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
DateTimeFormatInfo dtfi = frFR.DateTimeFormat;
Console.WriteLine("Before modifying DateSeparator property: {0}",
dateValue.ToString("g", frFR));
// Modify the date separator.
dtfi.DateSeparator = "-";
Console.WriteLine("After modifying the DateSeparator property: {0}",
dateValue.ToString("g", frFR));
}
}
// The example displays the following output:
// Before modifying DateSeparator property: 28/08/2013 00:00
// After modifying the DateSeparator property: 28-08-2013 00:00
Imports System.Globalization
Module Example
Public Sub Main()
Dim dateValue As New Date(2013, 08, 28)
Dim frFR As CultureInfo = CultureInfo.CreateSpecificCulture("fr-FR")
Dim dtfi As DateTimeFormatInfo = frFR.DateTimeFormat
Console.WriteLine("Before modifying DateSeparator property: {0}",
dateValue.ToString("g", frFR))
' Modify the date separator.
dtfi.DateSeparator = "-"
Console.WriteLine("After modifying the DateSeparator property: {0}",
dateValue.ToString("g", frFR))
End Sub
End Module
' The example displays the following output:
' Before modifying DateSeparator property: 28/08/2013 00:00
' After modifying the DateSeparator property: 28-08-2013 00:00
Cambio de las abreviaturas de nombre del día y el patrón de fecha larga
En algunos casos, el patrón de fecha larga, que normalmente muestra el nombre completo del día y del mes junto con el número del día del mes y el año, puede ser demasiado largo. 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 seguida del número de día, la abreviatura del nombre del mes y el año. Para ello, asigna abreviaturas de nombre de día más cortas a la AbbreviatedDayNames matriz y modifica la cadena de formato personalizado asignada a la LongDatePattern propiedad . Esto afecta a las cadenas de resultado devueltas por las cadenas de formato estándar "D" y "f".
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
DateTime value = new DateTime(2013, 7, 9);
CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
String[] formats = { "D", "F", "f" };
// Display date before modifying properties.
foreach (var fmt in formats)
Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));
Console.WriteLine();
// We don't want to change the FullDateTimePattern, so we need to save it.
String originalFullDateTimePattern = dtfi.FullDateTimePattern;
// Modify day name abbreviations and long date pattern.
dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
dtfi.FullDateTimePattern = originalFullDateTimePattern;
foreach (var fmt in formats)
Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));
}
}
// The example displays the following output:
// D: Tuesday, July 9, 2013
// F: Tuesday, July 9, 2013 12:00:00 AM
// f: Tuesday, July 9, 2013 12:00 AM
//
// D: Tu 09-Jul-2013
// F: Tuesday, July 9, 2013 12:00:00 AM
// f: Tu 09-Jul-2013 12:00 AM
Imports System.Globalization
Module Example
Public Sub Main()
Dim value As New Date(2013, 7, 9)
Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
Dim formats() As String = { "D", "F", "f" }
' Display date before modifying properties.
For Each fmt In formats
Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
Next
Console.WriteLine()
' We don't want to change the FullDateTimePattern, so we need to save it.
Dim originalFullDateTimePattern As String = dtfi.FullDateTimePattern
' Modify day name abbreviations and long date pattern.
dtfi.AbbreviatedDayNames = { "Su", "M", "Tu", "W", "Th", "F", "Sa" }
dtfi.LongDatePattern = "ddd dd-MMM-yyyy"
dtfi.FullDateTimePattern = originalFullDateTimePattern
For Each fmt In formats
Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
Next
End Sub
End Module
' The example displays the following output:
' D: Tuesday, July 9, 2013
' F: Tuesday, July 9, 2013 12:00:00 AM
' f: Tuesday, July 9, 2013 12:00 AM
'
' D: Tu 09-Jul-2013
' F: Tuesday, July 9, 2013 12:00:00 AM
' f: Tu 09-Jul-2013 12:00 AM
Normalmente, el cambio a la propiedad también afecta a la LongDatePatternFullDateTimePattern propiedad , que a su vez define la cadena de resultado devuelta por la cadena de formato estándar "F". Para conservar el patrón de fecha y hora completa original, el ejemplo reasigna la cadena de formato personalizado original asignada a la FullDateTimePattern propiedad después de modificar la LongDatePattern propiedad.
Cambio de un reloj de 12 horas a un reloj de 24 horas
Para muchas referencias culturales de .NET Framework, la hora se expresa mediante un reloj de 12 horas y un designador AM/PM. En el ejemplo siguiente se define un ReplaceWith24HourClock 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.
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. 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:
| Patrón | Descripción |
|---|---|
^ |
Empieza la búsqueda de coincidencias en el principio de la cadena. |
(?<openAMPM>\s*t+\s*)? |
Coincide con cero o una aparición de cero o más caracteres de espacio en blanco, seguidos de la letra "t" una o varias veces, seguidas de cero o más caracteres de espacio en blanco. Este grupo de captura se denomina openAMPM. |
(?(openAMPM) h+(?<nonHours>[^ht]+)$ |
Si el openAMPM grupo tiene una coincidencia, coincida con la letra "h" una o varias veces, seguida de uno o varios caracteres que no sean "h" ni "t". La coincidencia finaliza al final de la cadena. Todos los caracteres capturados después de "h" se incluyen en un grupo de captura denominado nonHours. |
| \s*h+(?<nonHours>[^ht]+)\s*t+) |
Si el openAMPM grupo no tiene una coincidencia, coincida con la letra "h" una o varias veces, seguida de uno o más caracteres que no sean "h" ni "t", seguidos de cero o más caracteres de espacio en blanco. Por último, coincide con una o varias apariciones de la letra "t". Todos los caracteres capturados después de "h" y antes de los espacios en blanco y "t" se incluyen en un grupo de captura denominado nonHours. |
El nonHours grupo de captura contiene el minuto y posiblemente el segundo componente de una cadena de formato de fecha y hora personalizada, junto con los símbolos separadores de hora. El patrón HH${nonHours} de reemplazo antepone la subcadena "HH" a estos elementos.
Mostrar y cambiar la era en una fecha
En el ejemplo siguiente se agrega el especificador de formato personalizado "g" a la LongDatePattern propiedad de un objeto que representa las convenciones de formato de la referencia cultural en-US. Esta adición afecta a las tres cadenas de formato estándar siguientes:
Cadena de formato estándar "D" (fecha larga), que se asigna directamente a la LongDatePattern propiedad .
Cadena de formato estándar "f" (fecha completa/hora corta), que genera una cadena de resultado que concatena las subcadenas producidas por las LongDatePattern propiedades y ShortTimePattern .
Cadena de formato estándar "F" (fecha completa/hora larga), que se asigna directamente a la FullDateTimePattern propiedad . Dado que no hemos establecido explícitamente este valor de propiedad, se genera dinámicamente mediante la concatenación de las LongDatePattern propiedades y LongTimePattern .
En el ejemplo también se muestra cómo cambiar el nombre de la era de una referencia cultural cuyo calendario tiene una sola era. En este caso, la referencia cultural en-US usa el calendario gregoriano, representado por un GregorianCalendar objeto . La GregorianCalendar clase admite una sola era, que denomina A.D. (Anno Domini). En el ejemplo se cambia el nombre de era a 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. El uso de una cadena literal es necesario, ya que normalmente el método devuelve el GetEraName nombre de la era de los datos privados de las tablas de referencia cultural proporcionadas por .NET Framework o el sistema operativo Windows.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
DateTime dateValue = new DateTime(2013, 5, 18, 13, 30, 0);
String[] formats = { "D", "f", "F" };
CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
String originalLongDatePattern = dtfi.LongDatePattern;
// Display the default form of three long date formats.
foreach (var fmt in formats)
Console.WriteLine(dateValue.ToString(fmt, dtfi));
Console.WriteLine();
// Modify the long date pattern.
dtfi.LongDatePattern = originalLongDatePattern + " g";
foreach (var fmt in formats)
Console.WriteLine(dateValue.ToString(fmt, dtfi));
Console.WriteLine();
// Change A.D. to C.E. (for Common Era)
dtfi.LongDatePattern = originalLongDatePattern + @" 'C.E.'";
foreach (var fmt in formats)
Console.WriteLine(dateValue.ToString(fmt, dtfi));
}
}
// The example displays the following output:
// Saturday, May 18, 2013
// Saturday, May 18, 2013 1:30 PM
// Saturday, May 18, 2013 1:30:00 PM
//
// Saturday, May 18, 2013 A.D.
// Saturday, May 18, 2013 A.D. 1:30 PM
// Saturday, May 18, 2013 A.D. 1:30:00 PM
//
// Saturday, May 18, 2013 C.E.
// Saturday, May 18, 2013 C.E. 1:30 PM
// Saturday, May 18, 2013 C.E. 1:30:00 PM
Imports System.Globalization
Module Example
Public Sub Main()
Dim dateValue As New Date(2013, 5, 18, 13, 30, 0)
Dim formats() As String = { "D", "f", "F" }
Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
Dim originalLongDatePattern As String = dtfi.LongDatePattern
' Display the default form of three long date formats.
For Each fmt In formats
Console.WriteLine(dateValue.ToString(fmt, dtfi))
Next
Console.WriteLine()
' Modify the long date pattern.
dtfi.LongDatePattern = originalLongDatePattern + " g"
For Each fmt In formats
Console.WriteLine(dateValue.ToString(fmt, dtfi))
Next
Console.WriteLine()
' Change A.D. to C.E. (for Common Era)
dtfi.LongDatePattern = originalLongDatePattern + " 'C.E.'"
For Each fmt In formats
Console.WriteLine(dateValue.ToString(fmt, dtfi))
Next
End Sub
End Module
' The example displays the following output:
' Saturday, May 18, 2013
' Saturday, May 18, 2013 1:30 PM
' Saturday, May 18, 2013 1:30:00 PM
'
' Saturday, May 18, 2013 A.D.
' Saturday, May 18, 2013 A.D. 1:30 PM
' Saturday, May 18, 2013 A.D. 1:30:00 PM
'
' Saturday, May 18, 2013 C.E.
' Saturday, May 18, 2013 C.E. 1:30 PM
' Saturday, May 18, 2013 C.E. 1:30:00 PM
Análisis de cadenas de fecha y hora
El análisis implica convertir la representación de cadena de una fecha y hora en un DateTime valor o DateTimeOffset . Ambos tipos incluyen los Parsemétodos , TryParse, ParseExacty TryParseExact para admitir operaciones de análisis. Los Parse métodos y TryParse convierten una cadena que puede tener una variedad de formatos, mientras ParseExact que y TryParseExact requieren que la cadena tenga un formato o formato definido. Si se produce un error Parse en la operación de análisis y ParseExact se produce una excepción, mientras que TryParse y TryParseExact devuelven false.
Los métodos de análisis usan implícita o explícitamente un DateTimeStyles valor de enumeración para determinar qué elementos de estilo (como el espacio en blanco inicial, final o interno) pueden estar presentes en la cadena que se va a analizar y cómo interpretar la cadena analizada o los elementos que faltan. Si no proporciona un DateTimeStyles valor al llamar al Parse método o TryParse , el valor predeterminado es DateTimeStyles.AllowWhiteSpaces, que es un estilo compuesto que incluye las DateTimeStyles.AllowLeadingWhitemarcas , DateTimeStyles.AllowTrailingWhitey DateTimeStyles.AllowInnerWhite . Para los ParseExact métodos y TryParseExact , el valor predeterminado es DateTimeStyles.None; la cadena de entrada debe corresponder precisamente a una cadena de formato de fecha y hora personalizada determinada.
Los métodos de análisis también usan implícita o explícitamente un DateTimeFormatInfo objeto que define los símbolos y patrones específicos que se pueden producir en la cadena que se van a analizar. Si no proporciona un DateTimeFormatInfo objeto , el DateTimeFormatInfo objeto de la referencia cultural actual se usa de forma predeterminada. Para obtener más información sobre el análisis de cadenas de fecha y hora, vea los métodos de análisis individuales, como DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExacty DateTimeOffset.TryParseExact.
En el ejemplo siguiente se muestra la naturaleza sensible a la referencia cultural de analizar cadenas de fecha y hora. Intenta analizar dos cadenas de fecha mediante las convenciones de las referencias culturales en-US, en-GB, fr-FR y fi-FI. La fecha que se interpreta como 18/8/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 de mes. 2/1/2015 se analiza como el segundo día del primer mes en la cultura en-US, pero como primer día del segundo mes en las referencias culturales restantes.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
string[] dateStrings = { "08/18/2014", "01/02/2015" };
string[] cultureNames = { "en-US", "en-GB", "fr-FR", "fi-FI" };
foreach (var cultureName in cultureNames) {
CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
Console.WriteLine("Parsing strings using the {0} culture.",
culture.Name);
foreach (var dateStr in dateStrings) {
try {
Console.WriteLine(String.Format(culture,
" '{0}' --> {1:D}", dateStr,
DateTime.Parse(dateStr, culture)));
}
catch (FormatException) {
Console.WriteLine(" Unable to parse '{0}'", dateStr);
}
}
}
}
}
// The example displays the following output:
// Parsing strings using the en-US culture.
// '08/18/2014' --> Monday, August 18, 2014
// '01/02/2015' --> Friday, January 02, 2015
// Parsing strings using the en-GB culture.
// Unable to parse '08/18/2014'
// '01/02/2015' --> 01 February 2015
// Parsing strings using the fr-FR culture.
// Unable to parse '08/18/2014'
// '01/02/2015' --> dimanche 1 février 2015
// Parsing strings using the fi-FI culture.
// Unable to parse '08/18/2014'
// '01/02/2015' --> 1. helmikuuta 2015
Imports System.Globalization
Module Example
Public Sub Main()
Dim dateStrings() As String = { "08/18/2014", "01/02/2015" }
Dim cultureNames() As String = { "en-US", "en-GB", "fr-FR", "fi-FI" }
For Each cultureName In cultureNames
Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
Console.WriteLine("Parsing strings using the {0} culture.",
culture.Name)
For Each dateStr In dateStrings
Try
Console.WriteLine(String.Format(culture,
" '{0}' --> {1:D}", dateStr,
DateTime.Parse(dateStr, culture)))
Catch e As FormatException
Console.WriteLine(" Unable to parse '{0}'", dateStr)
End Try
Next
Next
End Sub
End Module
' The example displays the following output:
' Parsing strings using the en-US culture.
' '08/18/2014' --> Monday, August 18, 2014
' '01/02/2015' --> Friday, January 02, 2015
' Parsing strings using the en-GB culture.
' Unable to parse '08/18/2014'
' '01/02/2015' --> 01 February 2015
' Parsing strings using the fr-FR culture.
' Unable to parse '08/18/2014'
' '01/02/2015' --> dimanche 1 février 2015
' Parsing strings using the fi-FI culture.
' Unable to parse '08/18/2014'
' '01/02/2015' --> 1. helmikuuta 2015
Normalmente, las cadenas de fecha y hora se analizan por dos motivos:
Para convertir la entrada del usuario en un valor de fecha y hora.
Para realizar un recorrido de ida y vuelta un valor de fecha y hora; es decir, para deserializar un valor de fecha y hora que se serializó previamente como una cadena.
En las secciones siguientes se describen estas dos operaciones con mayor detalle.
Análisis de cadenas de usuario
Al analizar la entrada de cadenas de fecha y hora por parte del usuario, siempre debe crear una instancia de un DateTimeFormatInfo objeto que refleje la configuración cultural del usuario, incluidas las personalizaciones que pueda haber realizado el usuario. De lo contrario, el objeto de fecha y hora puede tener valores incorrectos. Para obtener información sobre cómo crear instancias de un DateTimeFormatInfo objeto que refleje las personalizaciones culturales del usuario, consulte la sección DateTimeFormatInfo y datos dinámicos .
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 lo hace. En este caso, la referencia cultural predeterminada del sistema es en-US, pero el usuario ha usado Panel de control, Región e idioma para cambiar el patrón de fecha corta de su valor predeterminado de "M/d/aaaa" a "aaaa/MM/dd". Cuando el usuario escribe una cadena que refleja la configuración del usuario y un DateTimeFormatInfo objeto que también refleja la configuración del usuario (invalidaciones), la operación de análisis devuelve un resultado correcto. Sin embargo, cuando un DateTimeFormatInfo objeto analiza la cadena que refleja la configuración cultural estándar en-US, el método de análisis produce una FormatException excepción porque interpreta 14 como el número del mes, no los dos últimos dígitos del año.
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 hora
Se espera que los datos de fecha y hora serializados se redondee; es decir, todos los valores serializados y deserializados deben ser idénticos. Si un valor de fecha y hora representa un solo momento en el tiempo, el valor deserializado debe representar el mismo momento en el tiempo independientemente de la referencia cultural o zona horaria del sistema en el que se restauró. Para los datos de fecha y hora de ida y vuelta correctamente, debe usar las convenciones de la referencia cultural invariable, que devuelve la InvariantInfo propiedad , para generar y analizar los datos. Las operaciones de formato y análisis nunca deben reflejar las convenciones de la referencia cultural predeterminada. 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 cultura es idéntica a la del subproceso en el que se serializó. En algunos casos, esto significa que los datos ni siquiera se pueden serializar y deserializar correctamente en el mismo sistema.
Si el componente de hora de un valor de fecha y hora es significativo, también debe convertirse a UTC y serializarse mediante la cadena de formato estándar "o" o "r". A continuación, los datos de hora se pueden restaurar llamando a un método de análisis y pasando la cadena de formato adecuada junto con la referencia cultural invariable como provider argumento.
En el ejemplo siguiente se muestra el proceso de ida y vuelta de un valor de fecha y hora. Serializa una fecha y hora en un sistema que observa la hora del Pacífico de EE. UU. y cuya referencia cultural actual es 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 de un sistema en la zona horaria Bruselas, Copenhague, Madrid y París y cuya cultura actual es fr-FR. La fecha restaurada es nueve horas más tarde que la fecha original, que refleja el ajuste de zona horaria de ocho horas detrás de UTC a una hora antes de UTC. Tanto la fecha original como la fecha restaurada representan el mismo momento en el tiempo.
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). |
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. |
| AbbreviatedMonthGenitiveNames |
Obtiene o establece una matriz de cadenas de nombres abreviados de los meses asociada al objeto DateTimeFormatInfo actual. |
| AbbreviatedMonthNames |
Obtiene o establece una matriz de cadenas de una dimensión que contiene abreviaturas específicas de la referencia cultural de los meses. |
| AMDesignator |
Obtiene o establece el designador de cadena para las horas que son "ante meridiem" (antes de mediodía). |
| Calendar |
Obtiene o establece el calendario que se utilizará para la referencia cultural actual. |
| CalendarWeekRule |
Obtiene o establece el valor que especifica la regla que se utiliza para determinar la primera semana del calendario del año. |
| CurrentInfo |
Obtiene un objeto DateTimeFormatInfo de solo lectura que aplica formato a los valores basándose en la referencia cultural actual. |
| DateSeparator |
Obtiene o establece la cadena que separa los componentes de una fecha; es decir, el año, el mes y el día. |
| 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. |
| FirstDayOfWeek |
Obtiene o establece el primer día de la semana. |
| FullDateTimePattern |
Obtiene o establece la cadena de formato personalizado para un valor de fecha y hora largas. |
| InvariantInfo |
Obtiene el objeto DateTimeFormatInfo predeterminado de solo lectura que es independiente de la referencia cultural (invariable). |
| IsReadOnly |
Obtiene un valor que indica si el objeto DateTimeFormatInfo es de solo lectura. |
| LongDatePattern |
Obtiene o establece la cadena de formato personalizado para un valor de fecha larga. |
| LongTimePattern |
Obtiene o establece la cadena de formato personalizado para un valor de hora larga. |
| MonthDayPattern |
Obtiene o establece la cadena de formato personalizado para un valor de mes y día. |
| MonthGenitiveNames |
Obtiene o establece una matriz de cadenas de nombres de los meses asociada al objeto DateTimeFormatInfo actual. |
| 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. |
| NativeCalendarName |
Obtiene el nombre nativo del calendario asociado al objeto DateTimeFormatInfo actual. |
| PMDesignator |
Obtiene o establece el designador de cadena para las horas que son "post meridiem" (después de mediodía). |
| 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). |
| ShortDatePattern |
Obtiene o establece la cadena de formato personalizado para un valor de fecha corta. |
| 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. |
| ShortTimePattern |
Obtiene o establece la cadena de formato personalizado para un valor de hora corta. |
| SortableDateTimePattern |
Obtiene la cadena de formato personalizado para un valor de fecha y hora que se puede ordenar. |
| TimeSeparator |
Obtiene o establece la cadena que separa los componentes de una hora; es decir, la hora, los minutos y los segundos. |
| 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. |
| YearMonthPattern |
Obtiene o establece la cadena de formato personalizado para un valor de año y mes. |
Métodos
| Clone() |
Crea una copia superficial de la colección DateTimeFormatInfo. |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (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. |
| GetAbbreviatedEraName(Int32) |
Devuelve la cadena que contiene la abreviatura de la era especificada, si existe. |
| GetAbbreviatedMonthName(Int32) |
Para el mes especificado, devuelve su abreviatura según la referencia cultural asociada al objeto DateTimeFormatInfo actual. |
| GetAllDateTimePatterns() |
Devuelve todos los modelos estándar en los que se puede aplicar formato a los valores de fecha y hora. |
| 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. |
| GetDayName(DayOfWeek) |
Para el día de la semana especificado, devuelve su nombre completo según la referencia cultural asociada al objeto DateTimeFormatInfo actual. |
| GetEra(String) |
Devuelve el valor entero que representa la era especificada. |
| GetEraName(Int32) |
Devuelve la cadena que contiene el nombre de la era especificada. |
| GetFormat(Type) |
Devuelve un objeto del tipo especificado que proporciona un servicio de formato de fecha y hora. |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetInstance(IFormatProvider) |
Devuelve el objeto DateTimeFormatInfo asociado al objeto IFormatProvider especificado. |
| GetMonthName(Int32) |
Para el mes especificado, devuelve su nombre completo según la referencia cultural asociada al objeto DateTimeFormatInfo actual. |
| GetShortestDayName(DayOfWeek) |
Obtiene la abreviatura más corta para un día de la semana especificado asociado al objeto DateTimeFormatInfo actual. |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| ReadOnly(DateTimeFormatInfo) |
Devuelve un contenedor de DateTimeFormatInfo de solo lectura. |
| SetAllDateTimePatterns(String[], Char) |
Establece las cadenas del formato de fecha y hora personalizadas que corresponden a una cadena de formato estándar especificada. |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
Implementaciones de interfaz explícitas
| ISerializable.GetObjectData(SerializationInfo, StreamingContext) |
Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto de destino. |