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 objeto para la referencia DateTimeFormatInfo cultural inglés (Estados Unidos). Muestra el valor de las propiedades que contienen cadenas de formato personalizado y las usa 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 referencia cultural para dar formato o analizar valores de fecha y DateTimeFormatInfo hora como los siguientes:
Patrones usados para dar formato a los valores de fecha.
Patrones que se usan para dar formato a los valores de hora.
Nombres de los días de la semana.
Nombres de los meses del año.
The A.M. cono p.m. designadores 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 objeto puede representar las convenciones de formato de la referencia cultural invariable, una referencia cultural específica, una referencia DateTimeFormatInfo 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 tiene en cuenta 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 las referencia 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 invariable no cambian. Puede crear instancias de un objeto que represente las convenciones de formato de la referencia cultural DateTimeFormatInfo invariable de las maneras siguientes:
Recuperando el valor de la InvariantInfo propiedad . El objeto DateTimeFormatInfo devuelto es de solo lectura.
Llamando al constructor sin DateTimeFormatInfo parámetros. El objeto DateTimeFormatInfo devuelto es de lectura y escritura.
Recuperando el valor de la DateTimeFormat propiedad del objeto devuelto por la propiedad CultureInfo CultureInfo.InvariantCulture . El objeto DateTimeFormatInfo devuelto 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 que se habla en la Estados Unidos, y en-CA es una referencia cultural específica que representa el idioma inglés que se habla en Canadá. Puede crear instancias de un objeto que represente las convenciones de formato DateTimeFormatInfo de una referencia cultural específica de las maneras siguientes:
Llamando al CultureInfo.GetCultureInfo(String) método y recuperando el valor de la CultureInfo propiedad del objeto CultureInfo.DateTimeFormat devuelto. El objeto DateTimeFormatInfo devuelto es de solo lectura.
Pasando al método estático GetInstance un objeto que representa la referencia cultural cuyo objeto desea CultureInfo DateTimeFormatInfo recuperar. El objeto DateTimeFormatInfo devuelto es de lectura y escritura.
Llamando al método CultureInfo.CreateSpecificCulture estático y recuperando el valor de la CultureInfo propiedad del objeto CultureInfo.DateTimeFormat devuelto. El objeto DateTimeFormatInfo devuelto es de lectura y escritura.
Llamando al CultureInfo.CultureInfo constructor de clase y recuperando el valor de la propiedad del objeto CultureInfo CultureInfo.DateTimeFormat devuelto. El objeto DateTimeFormatInfo devuelto es de lectura y escritura.
En el ejemplo siguiente se muestra cada una de estas formas de crear instancias de un objeto e indica si el objeto resultante DateTimeFormatInfo 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 neutra representa una referencia cultural o un idioma que es independiente de un país o región; suele ser el elemento primario de una o varias referencia 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 instancias de un objeto que represente las convenciones de formato de una referencia cultural neutra de la misma manera que crea un objeto que representa las convenciones de formato de una DateTimeFormatInfo DateTimeFormatInfo referencia cultural específica. Además, puede recuperar el objeto de una referencia cultural neutra recuperando una referencia cultural neutra de la propiedad de una referencia cultural específica y recuperando el objeto devuelto DateTimeFormatInfo CultureInfo.Parent por su propiedad DateTimeFormatInfo CultureInfo.DateTimeFormat . A menos que la referencia cultural primaria represente la referencia cultural invariable, el DateTimeFormatInfo objeto devuelto 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 .NET Framework 1.0 a .NET Framework 3.5, al intentar recuperar un objeto que refleja las convenciones de formato de una referencia cultural neutra se produce una DateTimeFormatInfo NotSupportedException excepción.
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. En lugar de rellenar el objeto con valores genéricos, el .NET Framework devuelve un objeto que refleja las convenciones de formato de una referencia cultural específica que es un elemento secundario de la referencia DateTimeFormatInfo DateTimeFormatInfo cultural neutra. Por ejemplo, el objeto de la referencia cultural neutral en refleja las convenciones de formato de la referencia cultural en-US y el objeto de la referencia cultural fr refleja las convenciones de formato de la referencia cultural DateTimeFormatInfo DateTimeFormatInfo 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 DateTimeFormatInfo las 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 propiedades GregorianCalendar.CalendarType 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 objeto que represente las convenciones de formato DateTimeFormatInfo de la referencia cultural actual de las maneras siguientes:
Recuperando el valor de la CurrentInfo propiedad . El objeto DateTimeFormatInfo devuelto es de solo lectura.
Recuperando el valor de la DateTimeFormat propiedad del objeto devuelto por la propiedad CultureInfo CultureInfo.CurrentCulture . El objeto DateTimeFormatInfo devuelto es de solo lectura.
Llamando al método GetInstance con un objeto que representa la referencia cultural CultureInfo actual. El objeto DateTimeFormatInfo devuelto es de solo lectura.
En el ejemplo siguiente se usa cada uno de estos métodos para crear instancias de un objeto que representa las convenciones DateTimeFormatInfo 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 objeto DateTimeFormatInfo de cualquiera de las tres maneras anteriores y llamando al método en el objeto Clone DateTimeFormatInfo devuelto. Esto crea una copia del objeto DateTimeFormatInfo original, salvo que su IsReadOnly propiedad es
false.Llamando al método CultureInfo.CreateSpecificCulture para crear un objeto que representa la referencia cultural actual y, a continuación, usando su propiedad para recuperar el CultureInfo CultureInfo.DateTimeFormat DateTimeFormatInfo objeto.
En el ejemplo siguiente se muestra cada forma de crear instancias de un objeto de lectura y escritura DateTimeFormatInfo y se muestra el valor de su propiedad IsReadOnly .
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 operaciones de formato y análisis a través de la aplicación Región e idioma DateTimeFormatInfo en Panel de control. Por ejemplo, un usuario cuya referencia cultural es inglés (Estados Unidos) podría optar por mostrar valores de tiempo largo mediante 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 objetos recuperados de las formas que se han DateTimeFormatInfo analizado anteriormente reflejan estas invalidaciones de usuario. Si no quiere esto, puede crear un objeto que no refleje invalidaciones de usuario (y también es de lectura/escritura en lugar de solo lectura) llamando al constructor y suministrando un valor de para el argumento NumberFormatInfo CultureInfo.CultureInfo(String, Boolean) false useUserOverride . 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
DateTimeFormatInfo y datos dinámicos
Los datos específicos de la referencia cultural para dar formato a los valores de fecha y hora proporcionados por la clase son dinámicos, al igual que los DateTimeFormatInfo datos culturales proporcionados por la CultureInfo clase . No debe realizar ninguna suposición sobre la estabilidad de los valores de los DateTimeFormatInfo objetos asociados a objetos CultureInfo determinados. Solo los datos proporcionados por la referencia cultural invariable y su objeto DateTimeFormatInfo asociado 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 DateTimeFormatInfo de propiedad de una referencia cultural determinada.
Referencia cultural 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 que DateTimeFormatInfo 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 propiedad cambia a un objeto asociado a la referencia cultural CurrentInfo actual. De forma similar, el calendario de una referencia cultural puede cambiar, lo que puede dar lugar a cambios en numerosos valores DateTimeFormatInfo de propiedad.
Preferencias del usuario. Los usuarios de la aplicación pueden optar por invalidar algunos de los valores asociados a la referencia cultural actual del sistema a través de las opciones regional y de idioma en Panel de control. Por ejemplo, los usuarios pueden optar por mostrar la fecha en un formato diferente. Si la CultureInfo.UseUserOverride propiedad se establece en , las propiedades del objeto también se
trueDateTimeFormatInfo recuperan de la configuración del usuario. Si la configuración del usuario no es compatible con la referencia cultural asociada al objeto (por ejemplo, si el calendario seleccionado no es uno de los calendarios indicados por la propiedad ), los resultados de los métodos y los valores de las propiedades son CultureInfo OptionalCalendars indefinidos.
Para minimizar la posibilidad de datos incoherentes, todas las propiedades reemplazables por el usuario de un objeto se DateTimeFormatInfo inicializan cuando se crea el objeto. Todavía existe la posibilidad de incoherencia, porque ni la creación de objetos ni el proceso de invalidación de usuario son atómicos y los valores pertinentes pueden cambiar durante la creación del objeto. Sin embargo, esta situación debería ser muy poco frecuente.
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 objeto e indica si el objeto DateTimeFormatInfo resultante refleja invalidaciones de usuario.
| Origen del objeto CultureInfo y DateTimeFormatInfo | Refleja 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 una razón atractiva para hacer lo contrario, debe respetar las invalidaciones de usuario cuando use el objeto en las aplicaciones cliente para dar formato y analizar la entrada del usuario o para DateTimeFormatInfo mostrar datos. En el caso de las aplicaciones de servidor o desatendidas, no debe hacerlo. Sin embargo, si usa el objeto de forma explícita o implícita para conservar los datos de fecha y hora en forma de cadena, debe usar un 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 DateTimeFormatInfo DateTimeFormatInfo cultural.
Formato de 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) . A este método de devolución de llamada se Type le pasa un 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. El .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 objeto asociado a su propiedad DateTimeFormatInfo CultureInfo.DateTimeFormat .
Clase DateTimeFormatInfo , que proporciona información sobre las convenciones de formato de su referencia cultural asociada. El DateTimeFormatInfo.GetFormat método devuelve una instancia de sí mismo.
Si no se proporciona una implementación a un método de formato explícitamente, se usa el objeto devuelto por la propiedad que representa IFormatProvider CultureInfo la referencia cultural CultureInfo.CurrentCulture actual.
En el ejemplo siguiente se muestra la relación entre la IFormatProvider interfaz y la clase en las operaciones de DateTimeFormatInfo formato. Define una implementación personalizada IFormatProvider cuyo método muestra el tipo del objeto solicitado por la operación de GetFormat formato. Si solicita un objeto DateTimeFormatInfo , el método proporciona el objeto para la referencia cultural DateTimeFormatInfo actual. Como se muestra en la salida del ejemplo, el método solicita un objeto para proporcionar información de formato, mientras que el método solicita y objetos, así como Decimal.ToString(IFormatProvider) DateTimeFormatInfo una String.Format(IFormatProvider, String, Object[]) NumberFormatInfo DateTimeFormatInfo 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 operaciones de formato con valores de fecha y hora:
Propiedades relacionadas con el calendario. Propiedades como , , y , están asociadas al calendario utilizado por la referencia AbbreviatedDayNames AbbreviatedMonthNames DayNames MonthNames 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 resultados definida por estándares. Las RFC1123Pattern propiedades , y contienen SortableDateTimePattern UniversalSortableDateTimePattern cadenas de formato personalizado 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 la referencia cultural. Algunas propiedades, como FullDateTimePattern y , contienen ShortDatePattern cadenas de formato personalizado que especifican el formato de la cadena de resultado. Otros, como , , y , definen símbolos o AMDesignator DateSeparator PMDesignator subcadenas que distinguen la referencia cultural y que se TimeSeparator pueden incluir en una cadena de resultado.
Las cadenas deformato de fecha y hora estándar, como "d", "D", "f" y "F", son alias que se corresponden con propiedades de patrón de formato DateTimeFormatInfo determinadas. 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 el flujo de resultados. En la tabla siguiente se enumeran los especificadores de formato de fecha y hora estándar y personalizados y sus propiedades DateTimeFormatInfo asociadas. 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. A su vez, los especificadores individuales de esta cadena de formato personalizado corresponden a otras DateTimeFormatInfo propiedades. En la tabla solo se enumeran las propiedades para las que las cadenas de formato estándar son alias y no se enumeran las propiedades a las que pueden tener acceso las cadenas de formato personalizado asignadas a esas propiedades DateTimeFormatInfo con alias. Además, en la tabla solo se muestran especificadores de formato personalizados 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" (tiempo corto; cadena de formato estándar) | ShortTimePattern, para definir el formato general de la cadena de resultado. |
| "T" (larga duración; cadena de formato estándar) | LongTimePattern, para definir el formato general de la cadena de resultado. |
| "u" (fecha y hora universales ordenables; 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 universales; 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 de AM/PM completo en la cadena de resultado. |
| ":" (especificador de formato personalizado) | TimeSeparator, para incluir el separador de tiempo en la cadena de resultado. |
| "/" (especificador de formato personalizado) | DateSeparator, para incluir el separador de fechas en la cadena de resultado. |
Modificación de las propiedades DateTimeFormatInfo
Puede cambiar la cadena de resultados producida por cadenas de formato de fecha y hora modificando las propiedades asociadas de un objeto que se puede DateTimeFormatInfo escribir. Para determinar si un DateTimeFormatInfo objeto se puede escribir, use la propiedad IsReadOnly . Para personalizar un DateTimeFormatInfo objeto de esta manera:
Cree una copia de lectura y escritura de un DateTimeFormatInfo objeto cuyas convenciones de formato quiera modificar. (Vea 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 propiedades para definir cadenas de resultados, vea la sección anterior, Formato de cadenas y DateTimeFormatInfo propiedades DateTimeFormatInfo).
Use el objeto DateTimeFormatInfo personalizado que creó como argumento IFormatProvider en las llamadas a métodos de formato.
Hay otras dos maneras de cambiar el formato de una cadena de resultado:
Puede usar la clase para definir una referencia cultural personalizada (una referencia cultural que tiene un nombre único y que complementa las existentes) o una referencia cultural de reemplazo (una que se usa en lugar de una referencia cultural CultureAndRegionInfoBuilder específica). Puede guardar y acceder a esta referencia cultural mediante programación como haría con cualquier CultureInfo objeto compatible con el .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 personalizada. Por ejemplo, si va a serializar datos de fecha y hora con el formato YYYYMMDDHHmmss, puede generar la cadena de resultado pasando la cadena de formato personalizado al método y puede volver a convertir la cadena de resultado en un valor llamando DateTime.ToString(String) DateTime al método DateTime.ParseExact .
Cambio del patrón de fecha corta
En el ejemplo siguiente se cambia el formato de una cadena de resultado producida por la cadena de formato estándar "d" (fecha corta). Cambia la propiedad asociada de la referencia cultural en-US o inglés (Estados Unidos) de su valor predeterminado de ShortDatePattern "M/d/yyyy" a "yyyy'-"MM"-"dd" y usa la cadena de formato estándar "d" para mostrar la fecha antes y después de cambiar 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
Cambio del carácter separador de fechas
En el ejemplo siguiente se cambia el carácter separador de fecha en un objeto que representa DateTimeFormatInfo 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 DateSeparator cambiar la 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
Cambiar las abreviaturas de nombre de 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 abrevia el patrón de fecha larga para que la referencia cultural en-US devuelva una abreviatura de nombre de día de uno o dos caracteres seguido 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 matriz y modifica la cadena de formato AbbreviatedDayNames personalizado asignada a la propiedad LongDatePattern . 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 en la propiedad también afecta a la propiedad , que a su vez define la cadena de resultado devuelta por la cadena de formato estándar LongDatePattern FullDateTimePattern "F". Para conservar el patrón de fecha y hora completo original, en el ejemplo se reasigna la cadena de formato personalizado original asignada a la propiedad después de FullDateTimePattern LongDatePattern modificar la propiedad.
Cambio de un reloj de 12 horas a un reloj de 24 horas
Para muchas referencia culturales de la .NET Framework, la hora se expresa mediante un reloj de 12 horas y un designador am/PM. En el ejemplo siguiente se define un método que reemplaza cualquier formato de hora que usa un reloj de 12 horas por un formato que usa un reloj de ReplaceWith24HourClock 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 de expresión @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) 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, seguido de la letra "t" una o varias veces, seguido de cero o más caracteres de espacio en blanco. Este grupo de captura se denomina openAMPM . |
(?(openAMPM) h+(?<nonHours>[^ht]+)$ |
Si el grupo tiene una coincidencia, coincide con la letra "h" una o varias veces, seguida de uno o varios caracteres que no son openAMPM "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 grupo no tiene ninguna coincidencia, haga coincidir la letra "h" una o varias veces, seguida de uno o varios caracteres que no sean "h" ni "t", seguidos de cero o más caracteres de espacio en openAMPM 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 grupo de captura contiene el minuto y, posiblemente, el segundo componente de una cadena de formato de fecha y hora nonHours personalizado, junto con cualquier símbolo de separador de hora. El patrón de HH${nonHours} 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 propiedad de un objeto que representa las convenciones de formato de la referencia LongDatePattern 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 ShortTimePattern y .
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 LongTimePattern y .
En el ejemplo también se muestra cómo cambiar el nombre de era de una referencia cultural cuyo calendario tiene una sola era. En este caso, la referencia cultural en-US usa el calendario gregoriano, que se representa mediante un GregorianCalendar objeto . La GregorianCalendar clase admite una sola era, a la que denomina A.D. (Anno Domini). En el ejemplo se cambia el nombre de la era a C.E. (Era común) reemplazando el especificador de formato personalizado "g" en la cadena de formato asignada a la propiedad FullDateTimePattern por una cadena literal. El uso de una cadena literal es necesario, porque el método normalmente devuelve el nombre de la era a partir de datos privados en las tablas de referencia cultural proporcionadas por el sistema operativo .NET Framework o GetEraName 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 DateTimeOffset o . Ambos tipos incluyen los métodos , , y para Parse TryParse admitir operaciones de ParseExact TryParseExact análisis. Los métodos y convierten una cadena que puede tener una variedad de formatos, mientras que y requieren que la cadena tenga un formato o Parse TryParse ParseExact TryParseExact formatos definidos. Si se produce un error en la operación de análisis e Parse ParseExact inicia una excepción, mientras que TryParse y TryParseExact false devuelven .
Los métodos de análisis usan implícita o explícitamente un 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 DateTimeStyles faltan. Si no proporciona un valor al llamar al método o , el valor predeterminado es , que es un estilo compuesto que incluye las marcas DateTimeStyles Parse , y TryParse DateTimeStyles.AllowWhiteSpaces DateTimeStyles.AllowLeadingWhite DateTimeStyles.AllowTrailingWhite DateTimeStyles.AllowInnerWhite . Para los métodos y , el valor predeterminado es ; la cadena de entrada debe corresponder exactamente a una cadena de formato de fecha ParseExact TryParseExact y hora personalizada DateTimeStyles.None determinada.
Los métodos de análisis también usan implícita o explícitamente un objeto que define los símbolos y patrones específicos que pueden producirse en la cadena que se DateTimeFormatInfo va a analizar. Si no proporciona un objeto , el objeto de DateTimeFormatInfo la referencia cultural actual se usa de forma DateTimeFormatInfo 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 , y DateTimeOffset.ParseExact DateTimeOffset.TryParseExact .
En el ejemplo siguiente se muestra la naturaleza que tiene en cuenta la referencia cultural del análisis de cadenas de fecha y hora. Intenta analizar dos cadenas de fecha mediante las convenciones de las referencia culturales en-US, en-GB, fr-FR y fi-FI. La fecha que se interpreta como 8/18/2014 en la referencia cultural en-US produce una excepción en las otras tres referencia culturales porque 18 se interpreta como el número de FormatException mes. El 2/1/2015 se analiza como el segundo día del primer mes de la referencia cultural en-US, pero como el primer día del segundo mes en el resto de las referencia culturales.
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:
Para convertir la entrada del usuario en un valor de fecha y hora.
Para un valor de fecha y hora de ida y vuelta; es decir, para deserializar un valor de fecha y hora que se serializaba previamente como una cadena.
En las secciones siguientes se de abordan estas dos operaciones con más detalle.
Análisis de cadenas de usuario
Al analizar las cadenas de fecha y hora que haya especificado el usuario, siempre debe crear una instancia de un objeto que refleje la configuración cultural del usuario, incluidas las personalizaciones que el usuario pueda DateTimeFormatInfo haber realizado. De lo contrario, el objeto de fecha y hora puede tener valores incorrectos. Para obtener información sobre cómo crear instancias de un objeto que refleje las personalizaciones culturales del usuario, vea la DateTimeFormatInfo 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. 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/yyyy" a "yy/MM/dd". Cuando el usuario escribe una cadena que refleja la configuración del usuario y la cadena se analiza mediante un objeto que también refleja la configuración del usuario (invalidaciones), la operación de análisis devuelve un resultado DateTimeFormatInfo correcto. Sin embargo, cuando un objeto analiza la cadena que refleja la configuración cultural en-US estándar, el método de análisis produce una excepción porque interpreta 14 como el número del mes, no los dos DateTimeFormatInfo FormatException ú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
Serializar y deserializar datos de fecha y hora
Se espera que los datos serializados de fecha y hora sean de ida y vuelta. Es decir, todos los valores serializados y deserialados deben ser idénticos. Si un valor de fecha y hora representa un solo momento en el tiempo, el valor deserialado debe representar el mismo momento en el tiempo independientemente de la referencia cultural o la zona horaria del sistema en el que se restauró. Para que los datos de fecha y hora de ida y vuelta se usen correctamente, debe usar las convenciones de la referencia cultural invariable, que devuelve la propiedad , para generar y analizar InvariantInfo 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 sea idéntica a la del subproceso en el que se serializa. En algunos casos, esto significa que los datos no 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 se debe convertir a UTC y serializarse mediante la cadena de formato estándar "o" o "r". 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 de París, París, París, Norte de Francia y su referencia cultural actual es fr-FR. La fecha restaurada es nueve horas más tarde que la fecha original, lo que refleja el ajuste de zona horaria de ocho horas por detrás de utc a una hora por delante de la HORA 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. |