DateTimeFormatInfo Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Fornisce informazioni specifiche delle impostazioni cultura relative al formato dei valori di data e ora.
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- Ereditarietà
-
DateTimeFormatInfo
- Attributi
- Implementazioni
Esempio
Nell'esempio seguente viene utilizzata la reflection per ottenere le proprietà dell'oggetto per le impostazioni cultura DateTimeFormatInfo inglese (Stati Uniti). Visualizza il valore delle proprietà che contengono stringhe di formato personalizzate e le usa per visualizzare le date formattate.
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
Commenti
Le proprietà della classe contengono informazioni specifiche delle impostazioni cultura per la formattazione o l'analisi dei valori di DateTimeFormatInfo data e ora, ad esempio:
Modelli usati per formattare i valori di data.
Modelli usati per formattare i valori di ora.
Nomi dei giorni della settimana.
Nomi dei mesi dell'anno.
L'A.M. sia quello designatori usati nei valori di tempo.
Calendario in cui vengono espresse le date.
Contenuto della sezione:
Creazione di un'istanza di un oggetto DateTimeFormatInfo
Un oggetto può rappresentare le convenzioni di formattazione delle impostazioni cultura invarianti, impostazioni cultura specifiche, impostazioni cultura DateTimeFormatInfo neutre o impostazioni cultura correnti. Questa sezione illustra come creare un'istanza di ogni tipo di DateTimeFormatInfo oggetto.
Creazione di un'istanza di un oggetto DateTimeFormatInfo per le impostazioni cultura invarianti
Le impostazioni cultura invarianti rappresentano impostazioni cultura indipendenti dalle impostazioni cultura. Si basa sulla lingua inglese, ma non su un paese o un'area geografica specifica di lingua inglese. Anche se i dati di impostazioni cultura specifiche possono essere dinamici e possono cambiare per riflettere nuove convenzioni culturali o preferenze dell'utente, i dati delle impostazioni cultura invarianti non cambiano. È possibile creare un'istanza di un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura DateTimeFormatInfo invarianti nei modi seguenti:
Recuperando il valore della InvariantInfo proprietà . DateTimeFormatInfoL'oggetto restituito è di sola lettura.
Chiamando il costruttore senza DateTimeFormatInfo parametri. L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
Recuperando il valore della proprietà DateTimeFormat CultureInfo dall'oggetto restituito dalla CultureInfo.InvariantCulture proprietà . DateTimeFormatInfoL'oggetto restituito è di sola lettura.
Nell'esempio seguente viene utilizzato ognuno di questi metodi per creare un'istanza di un oggetto che rappresenta le impostazioni cultura DateTimeFormatInfo invarianti. Indica quindi se l'oggetto è di sola lettura.
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
Creazione di un'istanza di un oggetto DateTimeFormatInfo per impostazioni cultura specifiche
Impostazioni cultura specifiche rappresentano una lingua parlata in un determinato paese/area geografica. En-US, ad esempio, è una lingua specifica che rappresenta la lingua inglese parlata nel Stati Uniti e en-CA è una lingua specifica che rappresenta la lingua inglese parlata in Canada. È possibile creare un'istanza di un oggetto che DateTimeFormatInfo rappresenta le convenzioni di formattazione di impostazioni cultura specifiche nei modi seguenti:
Chiamando il CultureInfo.GetCultureInfo(String) metodo e recuperando il valore della proprietà CultureInfo dell'oggetto CultureInfo.DateTimeFormat restituito. DateTimeFormatInfoL'oggetto restituito è di sola lettura.
Passando al metodo statico GetInstance un oggetto che rappresenta le impostazioni cultura di cui si vuole recuperare CultureInfo DateTimeFormatInfo l'oggetto . L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
Chiamando il metodo statico CultureInfo.CreateSpecificCulture e recuperando il valore della proprietà CultureInfo dell'oggetto CultureInfo.DateTimeFormat restituito. L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
Chiamando il CultureInfo.CultureInfo costruttore della classe e recuperando il valore della proprietà CultureInfo dell'oggetto CultureInfo.DateTimeFormat restituito. L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
L'esempio seguente illustra ognuno di questi modi per creare un'istanza di un oggetto e DateTimeFormatInfo indica se l'oggetto risultante è di sola lettura.
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
Creazione di un'istanza di un oggetto DateTimeFormatInfo per impostazioni cultura non indipendenti
Le impostazioni cultura neutre rappresentano impostazioni cultura o lingua indipendenti da un paese o da un'area geografica. è in genere l'elemento padre di una o più impostazioni cultura specifiche. Ad esempio, Fr è una lingua neutra per la lingua francese e l'elemento padre delle impostazioni cultura fr-FR. È possibile creare un'istanza di un oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura neutre nello stesso modo in cui si crea un oggetto che rappresenta le convenzioni di formattazione DateTimeFormatInfo DateTimeFormatInfo di impostazioni cultura specifiche. È anche possibile recuperare l'oggetto di impostazioni cultura neutre recuperando impostazioni cultura neutre dalla proprietà di impostazioni cultura specifiche e recuperando l'oggetto restituito DateTimeFormatInfo dalla relativa proprietà CultureInfo.Parent DateTimeFormatInfo CultureInfo.DateTimeFormat . A meno che le impostazioni cultura padre non rappresentino le impostazioni cultura invarianti, l'oggetto DateTimeFormatInfo restituito è di lettura/scrittura. L'esempio seguente illustra questi modi per creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta impostazioni cultura neutre.
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
Nelle versioni .NET Framework da 1.0 a .NET Framework 3.5, il tentativo di recuperare un oggetto che riflette le convenzioni di formattazione di impostazioni cultura non indipendenti genera DateTimeFormatInfo NotSupportedException un'eccezione.
Tuttavia, le impostazioni cultura neutre non dispongono di informazioni di formattazione specifiche delle impostazioni cultura, perché sono indipendenti da un paese o un'area geografica specifica. Anziché popolare l'oggetto con valori generici, il .NET Framework restituisce un oggetto che riflette le convenzioni di formattazione di impostazioni cultura specifiche figlio delle impostazioni cultura DateTimeFormatInfo DateTimeFormatInfo non associate. Ad esempio, l'oggetto per le impostazioni cultura en neutre riflette le convenzioni di formattazione delle impostazioni cultura en-US e l'oggetto per le impostazioni cultura fr riflette le convenzioni di formattazione delle impostazioni cultura DateTimeFormatInfo DateTimeFormatInfo fr-FR.
È possibile usare codice simile al seguente per determinare le convenzioni di formattazione di impostazioni cultura specifiche rappresentate da impostazioni cultura non indipendenti. Nell'esempio viene utilizzata la reflection per DateTimeFormatInfo confrontare le proprietà di impostazioni cultura neutre con le proprietà di impostazioni cultura figlio specifiche. Considera due calendari equivalenti se sono dello stesso tipo di calendario e, per i calendari gregoriani, se le relative proprietà GregorianCalendar.CalendarType hanno valori identici.
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
Creazione di un'istanza di un oggetto DateTimeFormatInfo per le impostazioni cultura correnti
È possibile creare un'istanza di un oggetto che rappresenta le convenzioni di DateTimeFormatInfo formattazione delle impostazioni cultura correnti nei modi seguenti:
Recuperando il valore della CurrentInfo proprietà . DateTimeFormatInfoL'oggetto restituito è di sola lettura.
Recuperando il valore della proprietà DateTimeFormat CultureInfo dall'oggetto restituito dalla CultureInfo.CurrentCulture proprietà . DateTimeFormatInfoL'oggetto restituito è di sola lettura.
Chiamando il metodo GetInstance con un oggetto che rappresenta le impostazioni cultura CultureInfo correnti. DateTimeFormatInfoL'oggetto restituito è di sola lettura.
Nell'esempio seguente viene utilizzato ognuno di questi metodi per creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura correnti. Indica quindi se l'oggetto è di sola lettura.
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
È possibile creare un oggetto DateTimeFormatInfo scrivibile che rappresenta le convenzioni delle impostazioni cultura correnti in uno dei modi seguenti:
Recuperando un oggetto in uno dei tre modi precedenti e chiamando DateTimeFormatInfo il Clone metodo sull'oggetto DateTimeFormatInfo restituito. Verrà creata una copia dell'oggetto DateTimeFormatInfo originale, con la differenza che la IsReadOnly relativa proprietà è
false.Chiamando il metodo per creare un oggetto che rappresenta le impostazioni cultura correnti e quindi usando CultureInfo.CreateSpecificCulture la relativa proprietà per recuperare CultureInfo CultureInfo.DateTimeFormat DateTimeFormatInfo l'oggetto .
Nell'esempio seguente viene illustrata ogni modalità di creazione di un'istanza di un oggetto di lettura/scrittura DateTimeFormatInfo e viene visualizzato il valore della relativa proprietà 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
In Windows, l'utente può eseguire l'override di alcuni dei valori di proprietà usati nelle operazioni di formattazione e analisi tramite l'applicazione Area e lingua DateTimeFormatInfo in Pannello di controllo. Ad esempio, un utente le cui impostazioni cultura sono inglese (Stati Uniti) potrebbe scegliere di visualizzare valori di ora lunghi usando un orologio a 24 ore (nel formato HH:mm:ss) anziché l'orologio predefinito a 12 ore (nel formato h:mm:ss tt). Gli DateTimeFormatInfo oggetti recuperati nei modi descritti in precedenza riflettono tutti questi override utente. Se questa operazione non è desiderabile, è possibile creare un oggetto che non rifletta le sostituzioni utente (ed è anche di lettura/scrittura anziché di sola lettura) chiamando il costruttore e fornendo un valore per NumberFormatInfo CultureInfo.CultureInfo(String, Boolean) false l'argomento useUserOverride . L'esempio seguente illustra questo comportamento per un sistema le cui impostazioni cultura correnti sono inglese (Stati Uniti) e il cui modello temporale lungo è stato modificato dall'impostazione predefinita 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 e dati dinamici
I dati specifici delle impostazioni cultura per la formattazione dei valori di data e ora forniti dalla classe sono dinamici, proprio come i dati culturali DateTimeFormatInfo forniti dalla CultureInfo classe . Non è consigliabile fare ipotesi sulla stabilità dei valori per DateTimeFormatInfo gli oggetti associati a oggetti CultureInfo specifici. Solo i dati forniti dalle impostazioni cultura invarianti e dall'oggetto DateTimeFormatInfo associato sono stabili. Altri dati possono cambiare tra le sessioni dell'applicazione o anche durante l'esecuzione dell'applicazione. Esistono quattro principali origini di modifica:
Aggiornamenti di sistema. Le preferenze culturali, ad esempio il calendario preferito o i formati di data e ora personalizzati, cambiano nel tempo. In questo caso, Windows update include modifiche al valore DateTimeFormatInfo della proprietà per impostazioni cultura specifiche.
Impostazioni cultura di sostituzione. La CultureAndRegionInfoBuilder classe può essere utilizzata per sostituire i dati di impostazioni cultura esistenti.
Modifiche a catena ai valori delle proprietà. In fase di esecuzione è possibile modificare una serie di proprietà correlate alle impostazioni cultura che, a loro volta, causano DateTimeFormatInfo la modifica dei dati. Ad esempio, le impostazioni cultura correnti possono essere modificate a livello di codice o tramite l'azione dell'utente. In questo caso, DateTimeFormatInfo l'oggetto restituito dalla CurrentInfo proprietà cambia in un oggetto associato alle impostazioni cultura correnti. Analogamente, il calendario delle impostazioni cultura può cambiare e ciò può comportare modifiche a numerosi DateTimeFormatInfo valori di proprietà.
Preferenze dell'utente. Gli utenti dell'applicazione possono scegliere di eseguire l'override di alcuni dei valori associati alle impostazioni cultura di sistema correnti tramite le opzioni internazionali e della lingua in Pannello di controllo. Ad esempio, gli utenti possono scegliere di visualizzare la data in un formato diverso. Se la CultureInfo.UseUserOverride proprietà è impostata su
true, anche le proprietà DateTimeFormatInfo dell'oggetto vengono recuperate dalle impostazioni utente. Se le impostazioni utente non sono compatibili con le impostazioni cultura associate all'oggetto , ad esempio se il calendario selezionato non è uno dei calendari indicati dalla proprietà , i risultati dei metodi e dei valori delle proprietà non CultureInfo OptionalCalendars sono definiti.
Per ridurre al minimo la possibilità di dati incoerenti, tutte le proprietà sottoponibili a override dell'utente di un oggetto vengono DateTimeFormatInfo inizializzate al momento della creazione dell'oggetto. Esiste ancora una possibilità di incoerenza, perché né la creazione di oggetti né il processo di override dell'utente sono atomici e i valori rilevanti possono cambiare durante la creazione dell'oggetto. Tuttavia, questa situazione dovrebbe essere estremamente rara.
È possibile controllare se le sostituzioni utente vengono riflesse negli oggetti DateTimeFormatInfo che rappresentano le stesse impostazioni cultura delle impostazioni cultura di sistema. Nella tabella seguente sono elencati i modi in cui è possibile recuperare un oggetto e viene indicato se l'oggetto risultante riflette le DateTimeFormatInfo sostituzioni dell'utente.
| Origine dell'oggetto CultureInfo e DateTimeFormatInfo | Riflette le sostituzioni utente |
|---|---|
ProprietàCultureInfo.CurrentCulture.DateTimeFormat |
Sì |
| ProprietàDateTimeFormatInfo.CurrentInfo | Sì |
| Metodo CultureInfo.CreateSpecificCulture | Sì |
| Metodo CultureInfo.GetCultureInfo | No |
| Costruttore CultureInfo.CultureInfo(String) | Sì |
| Costruttore CultureInfo.CultureInfo(String, Boolean) | Dipende dal valore del useUserOverride parametro |
A meno che non vi sia un motivo valido per eseguire diversamente, è necessario rispettare le sostituzioni utente quando si usa l'oggetto nelle applicazioni client per formattare e analizzare l'input dell'utente o DateTimeFormatInfo per visualizzare i dati. Per le applicazioni server o le applicazioni automatica, non è consigliabile. Tuttavia, se si usa l'oggetto in modo esplicito o implicito per rendere persistenti i dati di data e ora in formato stringa, è necessario usare un oggetto che rifletta le convenzioni di formattazione delle impostazioni cultura DateTimeFormatInfo invarianti oppure è necessario specificare una stringa di formato di data e ora personalizzata da usare indipendentemente dalle impostazioni DateTimeFormatInfo cultura.
Formattazione di date e ore
Un DateTimeFormatInfo oggetto viene utilizzato in modo implicito o esplicito in tutte le operazioni di formattazione di data e ora. Sono incluse le chiamate ai metodi seguenti:
Tutti i metodi di formattazione di data e ora, ad DateTime.ToString() esempio e DateTimeOffset.ToString(String) .
Metodo di formattazione composita principale, ovvero String.Format .
Altri metodi di formattazione composita, ad Console.WriteLine(String, Object[]) esempio e StringBuilder.AppendFormat(String, Object[]) .
Tutte le operazioni di formattazione di data e ora usano IFormatProvider un'implementazione . IFormatProviderL'interfaccia include un singolo metodo, IFormatProvider.GetFormat(Type) . A questo metodo di callback viene passato Type un oggetto che rappresenta il tipo necessario per fornire informazioni di formattazione. Il metodo restituisce un'istanza di quel tipo o se non è in grado di null fornire un'istanza del tipo. Il .NET Framework include due IFormatProvider implementazioni per la formattazione di date e ore:
Classe CultureInfo , che rappresenta impostazioni cultura specifiche (o una lingua specifica in un paese o in un'area geografica specifica). In un'operazione di formattazione di data e ora, CultureInfo.GetFormat il metodo restituisce DateTimeFormatInfo l'oggetto associato alla CultureInfo.DateTimeFormat relativa proprietà .
Classe DateTimeFormatInfo , che fornisce informazioni sulle convenzioni di formattazione delle impostazioni cultura associate. Il DateTimeFormatInfo.GetFormat metodo restituisce un'istanza di .
Se un'implementazione non viene fornita in modo esplicito a un metodo di formattazione, viene utilizzato l'oggetto restituito dalla proprietà che rappresenta IFormatProvider CultureInfo le impostazioni cultura CultureInfo.CurrentCulture correnti.
Nell'esempio seguente viene illustrata la relazione tra IFormatProvider l'interfaccia e la classe nelle operazioni di DateTimeFormatInfo formattazione. Definisce un'implementazione IFormatProvider personalizzata il cui metodo visualizza il tipo GetFormat dell'oggetto richiesto dall'operazione di formattazione. Se richiede un oggetto , il DateTimeFormatInfo metodo fornisce DateTimeFormatInfo l'oggetto per le impostazioni cultura correnti. Come illustrato nell'output dell'esempio, il metodo richiede a un oggetto di fornire informazioni di formattazione, mentre il metodo richiede oggetti e Decimal.ToString(IFormatProvider) DateTimeFormatInfo String.Format(IFormatProvider, String, Object[]) NumberFormatInfo DateTimeFormatInfo ICustomFormatter un'implementazione.
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
Stringhe di formato e proprietà DateTimeFormatInfo
L'oggetto include tre tipi di proprietà utilizzate nelle operazioni di DateTimeFormatInfo formattazione con valori di data e ora:
Proprietà correlate al calendario. Proprietà quali , , e , sono associate al calendario utilizzato dalle impostazioni AbbreviatedDayNames AbbreviatedMonthNames DayNames MonthNames cultura, definite dalla Calendar proprietà . Queste proprietà vengono usate per i formati di data e ora lunghi.
Proprietà che producono una stringa di risultato definita da standard. Le RFC1123Pattern proprietà , e contengono stringhe di formato personalizzate che producono stringhe di risultato definite dagli standard SortableDateTimePattern UniversalSortableDateTimePattern internazionali. Queste proprietà sono di sola lettura e non possono essere modificate.
Proprietà che definiscono stringhe di risultato con distinzione delle impostazioni cultura. Alcune proprietà, ad esempio FullDateTimePattern e , contengono stringhe di formato ShortDatePattern personalizzate che specificano il formato della stringa di risultato. Altri, ad esempio , , e , definiscono simboli o sottostringhe con distinzione delle impostazioni cultura che AMDesignator possono essere inclusi in una stringa di DateSeparator PMDesignator TimeSeparator risultato.
Le stringhe di formato di data e ora standard,ad esempio "d", "D", "f" e "F", sono alias che corrispondono a particolari proprietà del modello DateTimeFormatInfo di formato. La maggior parte delle stringhe di formato di data e ora personalizzate è correlata a stringhe o sottostringhe inserite da un'operazione di formattazione nel flusso di risultati. Nella tabella seguente sono elencati gli identificatori di formato di data e ora standard e personalizzati e le relative proprietà DateTimeFormatInfo associate. Per informazioni dettagliate su come usare questi identificatori di formato, vedere Stringhe di formato di data e ora standard e Stringhe di formato di data e ora personalizzate. Si noti che ogni stringa di formato standard corrisponde a una DateTimeFormatInfo proprietà il cui valore è una stringa di formato di data e ora personalizzata. I singoli identificatori in questa stringa di formato personalizzata corrispondono a loro volta ad altre DateTimeFormatInfo proprietà. La tabella elenca solo le proprietà per le quali le stringhe di formato standard sono alias e non elenca le proprietà a cui possono accedere le stringhe di formato personalizzate assegnate a tali proprietà DateTimeFormatInfo con alias. Inoltre, la tabella elenca solo gli identificatori di formato personalizzati che corrispondono alle DateTimeFormatInfo proprietà.
| Identificatore di formato | Proprietà associate |
|---|---|
| "d" (data breve; stringa di formato standard) | ShortDatePatternper definire il formato complessivo della stringa di risultato. |
| "D" (data lunga; stringa di formato standard) | LongDatePatternper definire il formato complessivo della stringa di risultato. |
| "f" (data/ora breve completa; stringa di formato standard) | LongDatePatternper definire il formato del componente data della stringa di risultato. ShortTimePatternper definire il formato del componente ora della stringa di risultato. |
| "F" (data completa/ora lunga; stringa di formato standard) | LongDatePatternper definire il formato del componente data della stringa di risultato. LongTimePatternper definire il formato del componente ora della stringa di risultato. |
| "g" (data/ora breve generale; stringa di formato standard) | ShortDatePatternper definire il formato del componente data della stringa di risultato. ShortTimePatternper definire il formato del componente ora della stringa di risultato. |
| "G" (data/ora lunga generale; stringa di formato standard) | ShortDatePatternper definire il formato del componente data della stringa di risultato. LongTimePatternper definire il formato del componente ora della stringa di risultato. |
| "M", "m" (mese/giorno; stringa di formato standard) | MonthDayPatternper definire il formato complessivo della stringa di risultato. |
| "O", "o" (data/ora round trip; stringa di formato standard) | No. |
| "R", "r" (RFC1123; stringa di formato standard) | RFC1123Patternper definire una stringa di risultato conforme allo standard RFC 1123. la proprietà è di sola lettura. |
| "s" (data/ora ordinabile; stringa di formato standard) | SortableDateTimePattern, per definire una stringa di risultato conforme allo standard ISO 8601. la proprietà è di sola lettura. |
| "t" (ora breve; stringa di formato standard) | ShortTimePatternper definire il formato complessivo della stringa di risultato. |
| "T" (ora lunga; stringa di formato standard) | LongTimePatternper definire il formato complessivo della stringa di risultato. |
| "u" (data/ora ordinabile universale; stringa di formato standard) | UniversalSortableDateTimePattern, per definire una stringa di risultato conforme allo standard ISO 8601 per l'ora universale coordinata. la proprietà è di sola lettura. |
| "U" (data/ora completa universale; stringa di formato standard) | FullDateTimePattern, per definire il formato complessivo della stringa di risultato. |
| "Y", "y" (mese dell'anno; stringa di formato standard) | YearMonthPattern, per definire il formato complessivo della stringa di risultato. |
| "ddd" (identificatore di formato personalizzato) | AbbreviatedDayNames, per includere il nome abbreviato del giorno della settimana nella stringa di risultato. |
| "g", "gg" (identificatore di formato personalizzato) | Chiama il GetEraName metodo per inserire il nome dell'era nella stringa di risultato. |
| "MMM" (identificatore di formato personalizzato) | AbbreviatedMonthNames, per includere il nome abbreviato del mese nella stringa di risultato. |
| "MMMM" (identificatore di formato personalizzato) | MonthNames o MonthGenitiveNames per includere il nome completo del mese nella stringa di risultato. |
| "t" (identificatore di formato personalizzato) | AMDesignator o PMDesignator per includere il primo carattere dell'designatore AM/PM nella stringa di risultato. |
| "tt" (identificatore di formato personalizzato) | AMDesignator o PMDesignator per includere l'intero designatore AM/PM nella stringa di risultato. |
| ":" (identificatore di formato personalizzato) | TimeSeparator, per includere il separatore dell'ora nella stringa di risultato. |
| "/" (identificatore di formato personalizzato) | DateSeparator, per includere il separatore della data nella stringa di risultato. |
Modifica delle proprietà DateTimeFormatInfo
È possibile modificare la stringa di risultato prodotta dalle stringhe di formato di data e ora modificando le proprietà associate di un oggetto DateTimeFormatInfo scrivibile. Per determinare se DateTimeFormatInfo un oggetto è scrivibile, usare la IsReadOnly proprietà . Per personalizzare un DateTimeFormatInfo oggetto in questo modo:
Creare una copia di lettura/scrittura di un oggetto di cui si desidera modificare DateTimeFormatInfo le convenzioni di formattazione. Vedere la sezione Creazione di un'istanza di un oggetto DateTimeFormatInfo.
Modificare la proprietà o le proprietà utilizzate per produrre la stringa di risultato desiderata. Per informazioni su come i metodi di formattazione usano le proprietà per definire le stringhe di risultato, vedere la sezione precedente Stringhe di formato e proprietà DateTimeFormatInfo DateTimeFormatInfo.
Usare DateTimeFormatInfo l'oggetto personalizzato creato come argomento nelle chiamate ai metodi di IFormatProvider formattazione.
Esistono altri due modi per modificare il formato di una stringa di risultato:
È possibile usare la classe per definire impostazioni cultura personalizzate (impostazioni cultura con un nome univoco e che integrano le impostazioni cultura esistenti) o impostazioni cultura sostitutive (usate al posto di impostazioni cultura CultureAndRegionInfoBuilder specifiche). È possibile salvare e accedere a queste impostazioni cultura a livello di codice come qualsiasi oggetto CultureInfo supportato dal .NET Framework.
Se la stringa di risultato non è sensibile alle impostazioni cultura e non segue un formato predefinito, è possibile usare una stringa di formato di data e ora personalizzato. Ad esempio, se si serializzano dati di data e ora nel formato AAAAMMMMDHHmmss, è possibile generare la stringa di risultato passando la stringa di formato personalizzata al metodo ed è possibile convertire nuovamente la stringa di risultato in un valore DateTime.ToString(String) DateTime chiamando il metodo DateTime.ParseExact .
Modifica del modello di data breve
Nell'esempio seguente viene modificato il formato di una stringa di risultato prodotta dalla stringa di formato standard "d" (data breve). Modifica la proprietà associata per le impostazioni cultura en-US o english (Stati Uniti) dal valore predefinito ShortDatePattern "M/d/yyyy" a "yyyy'-"MM"-"dd" e usa la stringa di formato standard "d" per visualizzare la data prima e dopo la modifica ShortDatePattern della proprietà.
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
Modifica del carattere separatore di data
Nell'esempio seguente viene modificato il carattere separatore di data in un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura fr-FR. Nell'esempio viene utilizzata la stringa di formato standard "g" per visualizzare la data prima e dopo la DateSeparator modifica della proprietà .
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
Modifica delle abbreviazioni dei nomi dei giorni e del modello di data lunga
In alcuni casi, il modello di data lunga, che in genere visualizza il nome completo del giorno e del mese insieme al numero del giorno del mese e dell'anno, potrebbe essere troppo lungo. Nell'esempio seguente viene abbreviato il modello di data lungo per le impostazioni cultura en-US per restituire un'abbreviazione del nome di giorno di uno o due caratteri seguita dal numero del giorno, dall'abbreviazione del nome del mese e dall'anno. A tale scopo, assegna abbreviazioni del nome di giorno più brevi alla matrice e modificando la stringa di AbbreviatedDayNames formato personalizzata assegnata alla proprietà LongDatePattern . Ciò influisce sulle stringhe di risultato restituite dalle stringhe di formato standard "D" e "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
In genere, la modifica alla proprietà influisce anche sulla proprietà , che a sua volta definisce la stringa di risultato restituita dalla stringa LongDatePattern FullDateTimePattern di formato standard "F". Per mantenere il modello di data e ora completo originale, nell'esempio viene riassegnare la stringa di formato personalizzato originale assegnata alla proprietà dopo la FullDateTimePattern LongDatePattern modifica della proprietà .
Passaggio da un orologio a 12 ore a un orologio a 24 ore
Per molte impostazioni cultura nel .NET Framework, l'ora viene espressa usando un orologio di 12 ore e un designatore AM/PM. Nell'esempio seguente viene definito un metodo che sostituisce qualsiasi formato di ora che utilizza un formato a 12 ore con un formato che usa un formato ReplaceWith24HourClock a 24 ore.
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
Nell'esempio viene utilizzata un'espressione regolare per modificare la stringa di formato. Il criterio di espressione @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) regolare è definito come segue:
| Modello | Descrizione |
|---|---|
^ |
Inizia la ricerca della corrispondenza all'inizio della stringa. |
(?<openAMPM>\s*t+\s*)? |
Trova la corrispondenza con zero o una occorrenza di zero o più spazi vuoti, seguiti dalla lettera "t" una o più volte, seguita da zero o più spazi vuoti. Questo gruppo di acquisizione è denominato openAMPM . |
(?(openAMPM) h+(?<nonHours>[^ht]+)$ |
Se il gruppo ha una corrispondenza, trovare la corrispondenza con la lettera "h" una o più volte, seguita da uno o più caratteri che non sono openAMPM "h" né "t". La corrispondenza termina alla fine della stringa. Tutti i caratteri acquisiti dopo "h" vengono inclusi in un gruppo di acquisizione denominato nonHours . |
| \s*h+(?<nonHours>[^ht]+)\s*t+) |
Se il gruppo non ha una corrispondenza, trovare la corrispondenza con la lettera "h" una o più volte, seguita da uno o più caratteri che non sono né "h" né "t", seguiti da zero o più spazi openAMPM vuoti. Trovare infine una o più occorrenze della lettera "t". Tutti i caratteri acquisiti dopo "h" e prima degli spazi vuoti e "t" vengono inclusi in un gruppo di acquisizione denominato nonHours . |
Il gruppo di acquisizione contiene il minuto ed eventualmente il secondo componente di una stringa di formato di data e ora nonHours personalizzato, insieme a qualsiasi simbolo separatore dell'ora. Il criterio di HH${nonHours} sostituzione antepone la sottostringa "HH" a questi elementi.
Visualizzazione e modifica dell'era in una data
Nell'esempio seguente viene aggiunto l'identificatore di formato personalizzato "g" alla proprietà di un oggetto che rappresenta le convenzioni di formattazione LongDatePattern delle impostazioni cultura en-US. Questa aggiunta influisce sulle tre stringhe di formato standard seguenti:
Stringa di formato standard "D" (data lunga), mappata direttamente alla LongDatePattern proprietà .
Stringa di formato standard "f" (data completa/ora breve), che produce una stringa di risultato che concatena le sottostringhe prodotte dalle LongDatePattern proprietà ShortTimePattern e .
Stringa di formato standard "F" (data completa/ora lunga), mappata direttamente alla FullDateTimePattern proprietà . Poiché questo valore della proprietà non è stato impostato in modo esplicito, viene generato dinamicamente concatenando le LongDatePattern proprietà LongTimePattern e .
L'esempio mostra anche come modificare il nome dell'era per le impostazioni cultura il cui calendario ha una sola era. In questo caso, le impostazioni cultura en-US utilizzano il calendario gregoriano, rappresentato da un GregorianCalendar oggetto . La GregorianCalendar classe supporta una singola era, che denomi A.D. (Anno Domini). Nell'esempio il nome dell'era viene modificato in C.E. (Era comune) sostituendo l'identificatore di formato personalizzato "g" nella stringa di formato assegnata alla FullDateTimePattern proprietà con una stringa letterale. L'uso di una stringa letterale è necessario perché il nome dell'era viene in genere restituito dal metodo dai dati privati nelle tabelle delle impostazioni cultura fornite dal 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
Analisi di stringhe di data e ora
L'analisi comporta la conversione della rappresentazione di stringa di una data e di un'ora in un DateTime valore DateTimeOffset o . Entrambi questi tipi includono i Parse metodi , , e per TryParse ParseExact TryParseExact supportare le operazioni di analisi. I metodi e convertono una stringa che può avere un'ampia gamma di formati, mentre e richiedono che la stringa Parse abbia uno o più formati TryParse ParseExact TryParseExact definiti. Se l'operazione di analisi non riesce Parse e ParseExact genera un'eccezione, mentre TryParse e TryParseExact restituiscono false .
I metodi di analisi usano in modo implicito o esplicito un valore di enumerazione per determinare quali elementi di stile(ad esempio, uno spazio iniziale, finale o interno) possono essere presenti nella stringa da analizzare e come interpretare la stringa analizzata o eventuali elementi DateTimeStyles mancanti. Se non si specifica un valore quando si chiama il metodo o , il valore predefinito è , ovvero uno stile composito che include i flag DateTimeStyles Parse , e TryParse DateTimeStyles.AllowWhiteSpaces DateTimeStyles.AllowLeadingWhite DateTimeStyles.AllowTrailingWhite DateTimeStyles.AllowInnerWhite . Per i metodi e , il valore predefinito è . La stringa di input deve corrispondere esattamente ParseExact a una determinata stringa di formato di data e ora TryParseExact DateTimeStyles.None personalizzato.
I metodi di analisi usano anche in modo implicito o esplicito un oggetto che definisce i simboli e i modelli specifici che possono verificarsi nella DateTimeFormatInfo stringa da analizzare. Se non si specifica un oggetto , per impostazione predefinita viene usato l'oggetto per DateTimeFormatInfo DateTimeFormatInfo le impostazioni cultura correnti. Per altre informazioni sull'analisi delle stringhe di data e ora, vedere i singoli metodi di analisi, ad esempio DateTime.Parse DateTime.TryParse , , e DateTimeOffset.ParseExact DateTimeOffset.TryParseExact .
Nell'esempio seguente viene illustrata la natura con distinzione delle impostazioni cultura dell'analisi delle stringhe di data e ora. Tenta di analizzare due stringhe di data usando le convenzioni delle impostazioni cultura en-US, en-GB, fr-FR e fi-FI. La data interpretata come 18/8/2014 nelle impostazioni cultura en-US genera un'eccezione nelle altre tre impostazioni cultura perché 18 viene interpretato come numero del FormatException mese. 02/01/2015 viene analizzato come secondo giorno del primo mese nelle impostazioni cultura en-US, ma come primo giorno del secondo mese nelle impostazioni cultura rimanenti.
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
Le stringhe di data e ora vengono in genere analizzate per due motivi:
Per convertire l'input dell'utente in un valore di data e ora.
Per eseguire il round trip di un valore di data e ora; per deserializzare un valore di data e ora serializzato in precedenza come stringa.
Le sezioni seguenti illustrano queste due operazioni in modo più dettagliato.
Analisi delle stringhe utente
Quando si analizzano le stringhe di data e ora immesse dall'utente, è sempre necessario creare un'istanza di un oggetto che rifletta le impostazioni cultura dell'utente, incluse eventuali personalizzazioni apportate DateTimeFormatInfo dall'utente. In caso contrario, l'oggetto data e ora potrebbe avere valori non corretti. Per informazioni su come creare un'istanza di un oggetto che riflette le personalizzazioni culturali dell'utente, DateTimeFormatInfo vedere la sezione DateTimeFormatInfo e dynamic data.
Nell'esempio seguente viene illustrata la differenza tra un'operazione di analisi che riflette le impostazioni cultura dell'utente e una che non lo fa. In questo caso, le impostazioni cultura di sistema predefinite sono en-US, ma l'utente ha usato Pannello di controllo, Area e Lingua per modificare il modello di data breve dal valore predefinito "M/d/aa" a "aa/MM/gg". Quando l'utente immette una stringa che riflette le impostazioni utente e la stringa viene analizzata da un oggetto che riflette anche le impostazioni utente (sostituzioni), l'operazione di analisi restituisce un DateTimeFormatInfo risultato corretto. Tuttavia, quando la stringa viene analizzata da un oggetto che riflette le impostazioni cultura en-US standard, il metodo di analisi genera un'eccezione perché interpreta 14 come numero del mese, non le ultime due cifre DateTimeFormatInfo FormatException dell'anno.
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
Serializzazione e deserializzazione di dati di data e ora
Si prevede che i dati di data e ora serializzati eserendano il round trip. ciò significa che tutti i valori serializzati e deserializzati devono essere identici. Se un valore di data e ora rappresenta un singolo momento, il valore deserializzato deve rappresentare lo stesso momento indipendentemente dalle impostazioni cultura o dal fuso orario del sistema in cui è stato ripristinato. Per eseguire correttamente il round trip dei dati relativi a data e ora, è necessario usare le convenzioni delle impostazioni cultura invarianti, restituite dalla proprietà , per generare e analizzare InvariantInfo i dati. Le operazioni di formattazione e analisi non devono mai riflettere le convenzioni delle impostazioni cultura predefinite. Se si usano impostazioni cultura predefinite, la portabilità dei dati è rigorosamente limitata. può essere deserializzato correttamente solo in un thread le cui impostazioni specifiche della lingua sono identiche a quelle del thread in cui è stato serializzato. In alcuni casi, ciò significa che i dati non possono essere serializzati e deserializzati correttamente nello stesso sistema.
Se il componente relativo all'ora di un valore di data e ora è significativo, deve essere convertito anche in formato UTC e serializzato usando la stringa di formato standard "o" o "r". I dati relativi all'ora possono quindi essere ripristinati chiamando un metodo di analisi e passando la stringa di formato appropriata insieme alle impostazioni cultura invarianti come provider argomento.
Nell'esempio seguente viene illustrato il processo di round trip di un valore di data e ora. Serializza una data e un'ora in un sistema che osserva l'ora del Pacifico degli Stati Uniti e le cui impostazioni cultura correnti sono 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)
Deserializza i dati in un sistema nel fuso orario Disa, Città del Paese e Parigi e le cui impostazioni cultura correnti sono fr-FR. La data ripristinata è di nove ore successiva alla data originale, che riflette la regolazione del fuso orario da otto ore indietro rispetto all'ora UTC a un'ora prima dell'ora UTC. Sia la data originale che la data ripristinata rappresentano lo stesso momento nel tempo.
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
Costruttori
| DateTimeFormatInfo() |
Inizializza una nuova istanza scrivibile della classe DateTimeFormatInfo che è indipendente dalle impostazioni cultura (invariante). |
Proprietà
| AbbreviatedDayNames |
Ottiene o imposta una matrice unidimensionale di tipo String contenente i nomi abbreviati dei giorni della settimana specifici delle impostazioni cultura. |
| AbbreviatedMonthGenitiveNames |
Ottiene o imposta una matrice di stringhe di nomi abbreviati dei mesi associati all'oggetto DateTimeFormatInfo corrente. |
| AbbreviatedMonthNames |
Ottiene o imposta una matrice di stringhe unidimensionale contenente i nomi abbreviati dei mesi specifici delle impostazioni cultura. |
| AMDesignator |
Ottiene o imposta l'indicatore di stringa per le ore "ante meridiem" (prima di mezzogiorno). |
| Calendar |
Ottiene o imposta il calendario da usare per le impostazioni cultura correnti. |
| CalendarWeekRule |
Ottiene o imposta un valore che specifica la regola usata per determinare la prima settimana di calendario dell'anno. |
| CurrentInfo |
Ottiene un oggetto DateTimeFormatInfo di sola lettura che formatta i valori in base alle impostazioni cultura correnti. |
| DateSeparator |
Ottiene o imposta la stringa che separa i componenti di una data, ovvero l'anno, il mese e il giorno. |
| DayNames |
Ottiene o imposta una matrice di stringa unidimensionale contenente i nomi estesi dei giorni della settimana specifici delle impostazioni cultura. |
| FirstDayOfWeek |
Ottiene o imposta il primo giorno della settimana. |
| FullDateTimePattern |
Ottiene o imposta la stringa di formato personalizzata per un valore di data e ora estese. |
| InvariantInfo |
Ottiene l'oggetto DateTimeFormatInfo predefinito in sola lettura indipendente dalle impostazioni cultura associate alla lingua inglese. |
| IsReadOnly |
Ottiene un valore che indica se l'oggetto DateTimeFormatInfo è di sola lettura. |
| LongDatePattern |
Ottiene o imposta la stringa di formato personalizzata per un valore di data estesa. |
| LongTimePattern |
Ottiene o imposta la stringa di formato personalizzata per un valore di ora estesa. |
| MonthDayPattern |
Ottiene o imposta la stringa di formato personalizzata per un valore di mese e giorno. |
| MonthGenitiveNames |
Ottiene o imposta una matrice di stringhe di nomi di mesi associata all'oggetto DateTimeFormatInfo corrente. |
| MonthNames |
Ottiene o imposta una matrice unidimensionale di tipo String contenente i nomi estesi dei mesi specifici delle impostazioni cultura. |
| NativeCalendarName |
Ottiene il nome nativo del calendario associato all'oggetto DateTimeFormatInfo corrente. |
| PMDesignator |
Ottiene o imposta l'indicatore di stringa per le ore "post meridiem" (dopo mezzogiorno). |
| RFC1123Pattern |
Ottiene la stringa di formato personalizzata per un valore di data e ora basato sulla specifica IETF (Internet Engineering Task Force) RFC (Request for Comments) 1123. |
| ShortDatePattern |
Ottiene o imposta la stringa di formato personalizzata per un valore di data breve. |
| ShortestDayNames |
Ottiene o imposta una matrice di stringhe dei nomi univoci dei giorni abbreviati più corti associati all'oggetto DateTimeFormatInfo corrente. |
| ShortTimePattern |
Ottiene o imposta la stringa di formato personalizzata per un valore di ora breve. |
| SortableDateTimePattern |
Ottiene la stringa di formato personalizzata per un valore ordinabile di data e ora. |
| TimeSeparator |
Ottiene o imposta la stringa che separa i componenti dell'ora, ovvero l'ora, i minuti e i secondi. |
| UniversalSortableDateTimePattern |
Ottiene la stringa di formato personalizzato per una stringa di data e ora ordinabile e universale, come definito da ISO 8601. |
| YearMonthPattern |
Ottiene o imposta la stringa di formato personalizzata per un valore di anno e mese. |
Metodi
| Clone() |
Crea una copia superficiale di DateTimeFormatInfo. |
| Equals(Object) |
Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object) |
| GetAbbreviatedDayName(DayOfWeek) |
Restituisce il nome abbreviato specifico delle impostazioni cultura del giorno della settimana specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente. |
| GetAbbreviatedEraName(Int32) |
Restituisce la stringa contenente il nome abbreviato dell'era specificata, a condizione che esista un'abbreviazione. |
| GetAbbreviatedMonthName(Int32) |
Restituisce il nome abbreviato specifico delle impostazioni cultura del mese specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente. |
| GetAllDateTimePatterns() |
Restituisce tutti i modelli standard nei quali possono essere formattati i valori di data e ora. |
| GetAllDateTimePatterns(Char) |
Restituisce tutti i modelli standard nei quali possono essere formattati i valori di data e ora mediante la stringa di formato standard specificato. |
| GetDayName(DayOfWeek) |
Restituisce il nome completo specifico delle impostazioni cultura del giorno della settimana specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente. |
| GetEra(String) |
Restituisce l'intero che rappresenta l'era specificata. |
| GetEraName(Int32) |
Restituisce la stringa contenente il nome dell'era specificata. |
| GetFormat(Type) |
Restituisce un oggetto del tipo specificato che fornisce un servizio di formattazione data e ora. |
| GetHashCode() |
Funge da funzione hash predefinita. (Ereditato da Object) |
| GetInstance(IFormatProvider) |
Restituisce l'oggetto DateTimeFormatInfo associato all'oggetto IFormatProvider specificato. |
| GetMonthName(Int32) |
Restituisce il nome completo specifico delle impostazioni cultura del mese specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente. |
| GetShortestDayName(DayOfWeek) |
Ottiene il nome del giorno abbreviato più corto per un giorno della settimana specificato associato all'oggetto DateTimeFormatInfo corrente. |
| GetType() |
Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
| MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
| ReadOnly(DateTimeFormatInfo) |
Restituisce un wrapper DateTimeFormatInfo di sola lettura. |
| SetAllDateTimePatterns(String[], Char) |
Imposta le stringhe di formato di data e ora che corrispondono a una stringa di formato standard specificata. |
| ToString() |
Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object) |
Implementazioni dell'interfaccia esplicita
| ISerializable.GetObjectData(SerializationInfo, StreamingContext) |
Popola un elemento SerializationInfo con i dati necessari per la serializzazione dell'oggetto di destinazione. |