Classe DateTimeFormatInfo
Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.
Le proprietà della DateTimeFormatInfo classe contengono informazioni specifiche delle impostazioni cultura per la formattazione o l'analisi di valori di data e ora, ad esempio:
- Modelli utilizzati per formattare i valori di data.
- Modelli utilizzati per formattare i valori di ora.
- Nomi dei giorni della settimana.
- Nomi dei mesi dell'anno.
- I designatori A.M. e P.M. utilizzati nei valori temporali.
- Calendario in cui vengono espresse le date.
Creare un'istanza di un oggetto DateTimeFormatInfo
Un DateTimeFormatInfo oggetto può rappresentare le convenzioni di formattazione delle impostazioni cultura invarianti, impostazioni cultura specifiche, impostazioni cultura neutre o impostazioni cultura correnti. Questa sezione illustra come creare un'istanza di ogni tipo di DateTimeFormatInfo oggetto.
Creare un'istanza di un oggetto DateTimeFormatInfo per le impostazioni cultura invarianti
Le impostazioni cultura invarianti rappresentano impostazioni cultura senza distinzione tra impostazioni cultura. Si basa sulla lingua inglese, ma non su uno specifico paese/area geografica in lingua inglese. Anche se i dati di impostazioni cultura specifiche possono essere dinamici e possono cambiare per riflettere nuove convenzioni culturali o preferenze utente, i dati delle impostazioni cultura invarianti non cambiano. È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura invarianti nei modi seguenti:
- Recuperando il valore della InvariantInfo proprietà. L'oggetto restituito DateTimeFormatInfo è di sola lettura.
- Chiamando il costruttore senza DateTimeFormatInfo parametri. L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
- Recuperando il valore della DateTimeFormat proprietà dall'oggetto CultureInfo restituito dalla CultureInfo.InvariantCulture proprietà . L'oggetto restituito DateTimeFormatInfo è di sola lettura.
Nell'esempio seguente vengono usati ognuno di questi metodi per creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le impostazioni cultura 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
Creare un'istanza di un oggetto DateTimeFormatInfo per impostazioni cultura specifiche
Una cultura specifica rappresenta una lingua parlata in un determinato paese/area geografica. Ad esempio, en-US è una cultura specifica che rappresenta la lingua inglese parlata nel Stati Uniti e en-CA è una cultura specifica che rappresenta la lingua inglese parlata in Canada. È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura specifiche nei modi seguenti:
Chiamando il CultureInfo.GetCultureInfo(String) metodo e recuperando il valore della proprietà dell'oggetto CultureInfo.DateTimeFormat restituitoCultureInfo. L'oggetto restituito DateTimeFormatInfo è di sola lettura.
Passando il metodo statico GetInstance un CultureInfo oggetto che rappresenta le impostazioni cultura di cui DateTimeFormatInfo si desidera recuperare l'oggetto. L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
Chiamando il metodo statico CultureInfo.CreateSpecificCulture e recuperando il valore della proprietà dell'oggetto CultureInfo.DateTimeFormat restituitoCultureInfo. L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
Chiamando il costruttore della CultureInfo.CultureInfo classe e recuperando il valore della proprietà dell'oggetto CultureInfo.DateTimeFormat restituitoCultureInfo. L'oggetto restituito DateTimeFormatInfo è lettura/scrittura.
L'esempio seguente illustra ognuno di questi modi per creare un'istanza di un DateTimeFormatInfo oggetto e 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
Creare un'istanza di un oggetto DateTimeFormatInfo per impostazioni cultura neutre
Una cultura neutra rappresenta una cultura o una lingua indipendente da un paese/area geografica; è in genere l'elemento padre di una o più impostazioni cultura specifiche. Ad esempio, Fr è una cultura neutra per la lingua francese e l'elemento padre delle impostazioni cultura fr-FR. È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura neutre nello stesso modo in cui si crea un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura specifiche. Inoltre, è possibile recuperare l'oggetto DateTimeFormatInfo delle impostazioni cultura neutre recuperando impostazioni cultura neutre dalla proprietà di CultureInfo.Parent una cultura specifica e recuperando l'oggetto DateTimeFormatInfo restituito dalla relativa CultureInfo.DateTimeFormat proprietà. A meno che le impostazioni cultura padre non rappresentino le impostazioni cultura invarianti, l'oggetto restituito DateTimeFormatInfo è di lettura/scrittura. Nell'esempio seguente vengono illustrati 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
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 DateTimeFormatInfo con valori generici, .NET restituisce un DateTimeFormatInfo oggetto che riflette le convenzioni di formattazione di impostazioni cultura specifiche figlio delle impostazioni cultura neutre. Ad esempio, l'oggetto DateTimeFormatInfo per le impostazioni cultura en neutral riflette le convenzioni di formattazione delle impostazioni cultura en-US e l'oggetto DateTimeFormatInfo per le impostazioni cultura fr riflette le convenzioni di formattazione delle impostazioni cultura fr-FR.
È possibile usare codice simile al seguente per determinare le convenzioni di formattazione delle impostazioni cultura specifiche rappresentate da impostazioni cultura neutre. Nell'esempio viene utilizzata la reflection per confrontare le DateTimeFormatInfo 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 GregorianCalendar.CalendarType proprietà hanno valori identici.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
public class InstantiateEx6
{
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();
}
}
Creare un'istanza di un oggetto DateTimeFormatInfo per le impostazioni cultura correnti
È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura correnti nei modi seguenti:
Recuperando il valore della CurrentInfo proprietà. L'oggetto restituito DateTimeFormatInfo è di sola lettura.
Recuperando il valore della DateTimeFormat proprietà dall'oggetto CultureInfo restituito dalla CultureInfo.CurrentCulture proprietà . L'oggetto restituito DateTimeFormatInfo è di sola lettura.
Chiamando il GetInstance metodo con un CultureInfo oggetto che rappresenta le impostazioni cultura correnti. L'oggetto restituito DateTimeFormatInfo è di sola lettura.
Nell'esempio seguente vengono utilizzati 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
È possibile creare un oggetto scrivibile DateTimeFormatInfo che rappresenta le convenzioni delle impostazioni cultura correnti in uno dei modi seguenti:
Recuperando un DateTimeFormatInfo oggetto in uno dei tre modi precedenti e chiamando il Clone metodo sull'oggetto restituito DateTimeFormatInfo . Viene creata una copia dell'oggetto originale DateTimeFormatInfo , ad eccezione del fatto che la relativa IsReadOnly proprietà è
false.Chiamando il CultureInfo.CreateSpecificCulture metodo per creare un CultureInfo oggetto che rappresenta le impostazioni cultura correnti e quindi utilizzando la relativa CultureInfo.DateTimeFormat proprietà per recuperare l'oggetto DateTimeFormatInfo .
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 IsReadOnly proprietà.
using System;
using System.Globalization;
public class InstantiateEx1
{
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
In Windows, l'utente può eseguire l'override di alcuni dei valori delle DateTimeFormatInfo proprietà usati nelle operazioni di formattazione e analisi tramite l'applicazione Region and Language in Pannello di controllo. Ad esempio, un utente con impostazioni cultura inglese (Stati Uniti) potrebbe scegliere di visualizzare valori di tempo lunghi usando un orologio di 24 ore (nel formato HH:mm:ss) anziché l'orologio predefinito di 12 ore (nel formato h:mm:ss tt). Gli DateTimeFormatInfo oggetti recuperati nei modi descritti in precedenza riflettono tutte queste sostituzioni utente. Se ciò non è indesiderato, è possibile creare un NumberFormatInfo oggetto che non rifletta le sostituzioni dell'utente (ed è anche di lettura/scrittura invece di sola lettura) chiamando il CultureInfo.CultureInfo(String, Boolean) costruttore e fornendo un valore di false per l'argomento useUserOverride . Nell'esempio seguente viene illustrato questo valore per un sistema le cui impostazioni cultura correnti sono inglese (Stati Uniti) e il cui modello di tempo lungo è stato modificato dall'impostazione predefinita h:mm:ss tt a HH:mm:ss.
using System;
using System.Globalization;
public class InstantiateEx3
{
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
DateTimeFormatInfo e dati dinamici
I dati specifici delle impostazioni cultura per la formattazione dei valori di data e ora forniti dalla DateTimeFormatInfo classe sono dinamici, esattamente come i dati culturali forniti dalla CultureInfo classe . Non è consigliabile fare ipotesi sulla stabilità dei valori per DateTimeFormatInfo gli oggetti associati a oggetti specifici CultureInfo . Solo i dati forniti dalle impostazioni cultura invarianti e il relativo oggetto associato DateTimeFormatInfo sono stabili. Altri dati possono cambiare tra sessioni dell'applicazione o anche mentre l'applicazione è in esecuzione. Esistono quattro principali fonti di cambiamento:
Aggiornamenti del 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 della DateTimeFormatInfo proprietà per impostazioni cultura specifiche.
Impostazioni cultura di sostituzione. La CultureAndRegionInfoBuilder classe può essere usata per sostituire i dati di impostazioni cultura esistenti.
Modifiche a catena ai valori delle proprietà. Una serie di proprietà correlate alle impostazioni cultura può cambiare in fase di esecuzione, che, a sua volta, causa la modifica dei DateTimeFormatInfo dati. Ad esempio, le impostazioni cultura correnti possono essere modificate a livello di codice o tramite l'azione dell'utente. In questo caso, l'oggetto DateTimeFormatInfo restituito dalla CurrentInfo proprietà passa a un oggetto associato alle impostazioni cultura correnti. Analogamente, il calendario delle impostazioni cultura può cambiare, che può comportare modifiche a numerosi DateTimeFormatInfo valori delle proprietà.
Preferenze utente. Gli utenti dell'applicazione potrebbero scegliere di eseguire l'override di alcuni dei valori associati alle impostazioni cultura correnti del sistema tramite le opzioni internazionali e linguistiche in Pannello di controllo. Ad esempio, gli utenti potrebbero scegliere di visualizzare la data in un formato diverso. Se la CultureInfo.UseUserOverride proprietà è impostata su
true, le proprietà dell'oggetto DateTimeFormatInfo vengono recuperate anche dalle impostazioni utente. Se le impostazioni utente non sono compatibili con le impostazioni cultura associate all'oggetto CultureInfo , ad esempio se il calendario selezionato non è uno dei calendari indicati dalla OptionalCalendars proprietà , i risultati dei metodi e i valori delle proprietà non sono definiti.
Per ridurre al minimo la possibilità di dati incoerenti, tutte le proprietà sostituibili dall'utente di un DateTimeFormatInfo oggetto vengono inizializzate al momento della creazione dell'oggetto. Esiste ancora una possibilità di incoerenza, perché non è atomica né la creazione di oggetti né il processo di override dell'utente e i valori pertinenti possono cambiare durante la creazione dell'oggetto. Tuttavia, questa situazione dovrebbe essere estremamente rara.
È possibile controllare se le sostituzioni utente vengono riflesse in DateTimeFormatInfo oggetti che rappresentano le stesse impostazioni cultura delle impostazioni cultura del sistema. Nella tabella seguente sono elencati i modi in cui è possibile recuperare un DateTimeFormatInfo oggetto e indica se l'oggetto risultante riflette gli override 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 esista un motivo interessante per eseguire altre operazioni, è consigliabile rispettare le sostituzioni utente quando si usa l'oggetto DateTimeFormatInfo nelle applicazioni client per formattare e analizzare l'input dell'utente o per visualizzare i dati. Per le applicazioni server o le applicazioni automatiche, non è consigliabile. Tuttavia, se si utilizza l'oggetto DateTimeFormatInfo in modo esplicito o implicito per rendere persistenti i dati di data e ora sotto forma di stringa, è consigliabile utilizzare un DateTimeFormatInfo oggetto che rifletta le convenzioni di formattazione delle impostazioni cultura invarianti oppure specificare una stringa di formato di data e ora personalizzata utilizzata indipendentemente dalle impostazioni cultura.
Formattare date e ore
Un DateTimeFormatInfo oggetto viene utilizzato in modo implicito o esplicito in tutte le operazioni di formattazione di data e ora. Queste includono chiamate ai metodi seguenti:
- Tutti i metodi di formattazione di data e ora, ad esempio DateTime.ToString() e DateTimeOffset.ToString(String).
- Metodo di formattazione composito principale, ovvero String.Format.
- Altri metodi di formattazione composita, ad esempio Console.WriteLine(String, Object[]) e StringBuilder.AppendFormat(String, Object[]).
Tutte le operazioni di formattazione di data e ora usano un'implementazione IFormatProvider . L'interfaccia IFormatProvider include un singolo metodo, IFormatProvider.GetFormat(Type). Questo metodo di callback viene passato a un Type oggetto che rappresenta il tipo necessario per fornire informazioni di formattazione. Il metodo restituisce un'istanza di tale tipo o null se non è in grado di fornire un'istanza del tipo. .NET 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/area geografica specifica). In un'operazione di formattazione di data e ora, il CultureInfo.GetFormat metodo restituisce l'oggetto DateTimeFormatInfo associato alla relativa CultureInfo.DateTimeFormat proprietà.
- Classe DateTimeFormatInfo , che fornisce informazioni sulle convenzioni di formattazione delle impostazioni cultura associate. Il DateTimeFormatInfo.GetFormat metodo restituisce un'istanza di se stessa.
Se non viene fornita un'implementazione IFormatProvider a un metodo di formattazione in modo esplicito, viene utilizzato l'oggetto CultureInfo restituito dalla CultureInfo.CurrentCulture proprietà che rappresenta le impostazioni cultura correnti.
Nell'esempio seguente viene illustrata la relazione tra l'interfaccia IFormatProvider e la DateTimeFormatInfo classe nelle operazioni di formattazione. Definisce un'implementazione personalizzata IFormatProvider il cui GetFormat metodo visualizza il tipo dell'oggetto richiesto dall'operazione di formattazione. Se richiede un DateTimeFormatInfo oggetto , il metodo fornisce l'oggetto DateTimeFormatInfo per le impostazioni cultura correnti. Come illustrato nell'output dell'esempio, il Decimal.ToString(IFormatProvider) metodo richiede a un DateTimeFormatInfo oggetto di fornire informazioni di formattazione, mentre il String.Format(IFormatProvider, String, Object[]) metodo richiede NumberFormatInfo e DateTimeFormatInfo oggetti nonché un'implementazione ICustomFormatter .
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 FormatProviderEx1
{
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
Formattare stringhe e proprietà DateTimeFormatInfo
L'oggetto DateTimeFormatInfo include tre tipi di proprietà utilizzate nelle operazioni di formattazione con valori di data e ora:
Proprietà correlate al calendario. Le proprietà, ad esempio AbbreviatedDayNames, DayNamesAbbreviatedMonthNames, e MonthNames, sono associate al calendario usato dalle impostazioni cultura, definite dalla Calendar proprietà . Queste proprietà vengono utilizzate per formati di data e ora lunghi.
Proprietà che producono una stringa di risultati definita da standard. Le RFC1123Patternproprietà , SortableDateTimePatterne UniversalSortableDateTimePattern contengono stringhe di formato personalizzate che producono stringhe di risultato definite dagli standard internazionali. Queste proprietà sono di sola lettura e non possono essere modificate.
Proprietà che definiscono stringhe di risultati sensibili alle impostazioni cultura. Alcune proprietà, ad esempio FullDateTimePattern e ShortDatePattern, contengono stringhe di formato personalizzate che specificano il formato della stringa di risultato. Altri, ad esempio AMDesignator, DateSeparatorPMDesignator, e TimeSeparator, definiscono simboli o sottostringhe sensibili alle impostazioni cultura che possono essere inclusi in una stringa di risultato.
Le stringhe di formato di data e ora standard, ad esempio "d", "D", "f" e "F", sono alias che corrispondono a DateTimeFormatInfo specifiche proprietà del modello 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à associate DateTimeFormatInfo . 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 DateTimeFormatInfo proprietà per le quali le stringhe di formato standard sono alias e non elenca le proprietà a cui è possibile accedere da stringhe di formato personalizzate assegnate a tali proprietà 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 estesa; stringa di formato standard) | LongDatePatternper definire il formato complessivo della stringa di risultato. |
| "f" (data completa/ora breve; stringa di formato standard) | LongDatePatternper definire il formato del componente date della stringa di risultato. ShortTimePattern, per definire il formato del componente time della stringa di risultato. |
| "F" (data completa/ora estesa; stringa di formato standard) | LongDatePatternper definire il formato del componente date della stringa di risultato. LongTimePattern, per definire il formato del componente time della stringa di risultato. |
| "g" (data generale/ ora breve; stringa di formato standard) | ShortDatePatternper definire il formato del componente date della stringa di risultato. ShortTimePattern, per definire il formato del componente time della stringa di risultato. |
| "G" (data generale/ora estesa; stringa di formato standard) | ShortDatePatternper definire il formato del componente date della stringa di risultato. LongTimePattern, per definire il formato del componente time 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) | Nessuno. |
| "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) | SortableDateTimePatternper definire una stringa di risultato conforme allo standard ISO 8601. la proprietà è di sola lettura. |
| "t" (breve tempo; stringa di formato standard) | ShortTimePatternper definire il formato complessivo della stringa di risultato. |
| "T" (long time; standard format string) | LongTimePatternper definire il formato complessivo della stringa di risultato. |
| "u" (data/ora ordinabile universale; stringa di formato standard) | UniversalSortableDateTimePatternper definire una stringa di risultato conforme allo standard ISO 8601 per l'ora universale coordinata. la proprietà è di sola lettura. |
| "U" (universal full date/time; stringa di formato standard) | FullDateTimePatternper definire il formato complessivo della stringa di risultato. |
| "Y", "y" (anno mese; stringa di formato standard) | YearMonthPatternper 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 del mese abbreviato nella stringa di risultato. |
| "MMMM" (identificatore di formato personalizzato) | MonthNames oppure MonthGenitiveNamesper includere il nome completo del mese nella stringa di risultato. |
| "t" (identificatore di formato personalizzato) | AMDesignator o PMDesignator, per includere il primo carattere dell'identificatore 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 di data nella stringa di risultato. |
Modificare le proprietà DateTimeFormatInfo
È possibile modificare la stringa di risultato prodotta dalle stringhe di formato data e ora modificando le proprietà associate di un oggetto scrivibile DateTimeFormatInfo . Per determinare se un DateTimeFormatInfo oggetto è scrivibile, utilizzare la IsReadOnly proprietà . Per personalizzare un DateTimeFormatInfo oggetto in questo modo:
Creare una copia di lettura/scrittura di un DateTimeFormatInfo oggetto le cui convenzioni di formattazione si desidera modificare.
Modificare la proprietà o le proprietà utilizzate per produrre la stringa di risultato desiderata. Per informazioni su come i metodi di formattazione usano DateTimeFormatInfo le proprietà per definire le stringhe di risultato, vedere la sezione precedente, Format stringhe e proprietà DateTimeFormatInfo.
Usare l'oggetto personalizzato DateTimeFormatInfo creato come IFormatProvider argomento nelle chiamate ai metodi di formattazione.
Esistono due altri modi per modificare il formato di una stringa di risultato:
È possibile usare la CultureAndRegionInfoBuilder classe per definire impostazioni cultura personalizzate (impostazioni cultura con un nome univoco e che integrano le impostazioni cultura esistenti) o impostazioni cultura di sostituzione (una usata anziché impostazioni cultura specifiche). È possibile salvare e accedere a queste impostazioni cultura a livello di codice come qualsiasi CultureInfo oggetto supportato da .NET.
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 personalizzata. Ad esempio, se si serializzano i dati di data e ora nel formato AAAAMMGGHHmmss, è possibile generare la stringa di risultato passando la stringa di formato personalizzata al DateTime.ToString(String) metodo ed è possibile convertire nuovamente la stringa di risultato in un DateTime valore chiamando il DateTime.ParseExact metodo .
Modificare il 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 ShortDatePattern per le impostazioni cultura en-US o English (Stati Uniti) dal valore predefinito "M/d/aaaa" a "yyyy'-"MM"-"dd" e usa la stringa di formato standard "d" per visualizzare la data sia prima che dopo la modifica della ShortDatePattern proprietà.
using System;
using System.Globalization;
public class Example1
{
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
Modificare il 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 modifica della DateSeparator proprietà.
using System;
using System.Globalization;
public class Example3
{
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
Modificare le abbreviazioni del nome del giorno e il modello di data estesa
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, può essere troppo lungo. Nell'esempio seguente viene abbreviato il modello di data estesa per le impostazioni cultura en-US in modo da restituire un'abbreviazione del nome di un carattere o di due caratteri seguita dal numero del giorno, dall'abbreviazione del nome del mese e dall'anno. A tale scopo, assegnare abbreviazioni di nome giorno più breve alla AbbreviatedDayNames matrice e modificando la stringa di formato personalizzata assegnata alla LongDatePattern proprietà . Ciò influisce sulle stringhe di risultato restituite dalle stringhe di formato standard "D" e "f".
using System;
using System.Globalization;
public class Example2
{
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
In genere, la modifica alla LongDatePattern proprietà influisce anche sulla FullDateTimePattern proprietà , che a sua volta definisce la stringa di risultato restituita dalla stringa di formato standard "F". Per mantenere il modello di data e ora completo originale, l'esempio riassegna la stringa di formato personalizzata originale assegnata alla FullDateTimePattern proprietà dopo la modifica della LongDatePattern proprietà.
Passare da un orologio di 12 ore a un orologio di 24 ore
Per molte impostazioni cultura in .NET, l'ora viene espressa usando un orologio di 12 ore e un designatore AM/PM. Nell'esempio seguente viene definito un ReplaceWith24HourClock metodo che sostituisce qualsiasi formato di ora che utilizza un orologio di 12 ore con un formato che usa un orologio di 24 ore.
using System;
using System.Globalization;
using System.Text.RegularExpressions;
public class Example5
{
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
Nell'esempio viene utilizzata un'espressione regolare per modificare la stringa di formato. Il criterio @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) di espressione 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, seguita dalla lettera "t" una o più volte, seguita da zero o più caratteri di spazio vuoto. Questo gruppo di acquisizione è denominato openAMPM. |
(?(openAMPM) h+(?<nonHours>[^ht]+)$ |
Se il openAMPM gruppo ha una corrispondenza, trova la corrispondenza con la lettera "h" una o più volte, seguita da uno o più caratteri che non sono né "h" né "t". La corrispondenza termina alla fine della stringa. Tutti i caratteri acquisiti dopo "h" sono inclusi in un gruppo di acquisizione denominato nonHours. |
| \s*h+(?<nonHours>[^ht]+)\s*t+) |
Se il openAMPM gruppo non ha una corrispondenza, trova 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ù caratteri di spazio vuoto. Infine, trovare una o più occorrenze della lettera "t". Tutti i caratteri acquisiti dopo "h" e prima che gli spazi vuoti e "t" siano inclusi in un gruppo di acquisizione denominato nonHours. |
Il nonHours gruppo di acquisizione contiene il minuto ed eventualmente il secondo componente di una stringa di formato di data e ora personalizzata, insieme ai simboli separatori di ora. Il modello HH${nonHours} di sostituzione antepone la sottostringa "HH" a questi elementi.
Visualizzare e modificare l'era in una data
Nell'esempio seguente viene aggiunto l'identificatore di formato personalizzato "g" alla LongDatePattern proprietà di un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura en-US. Questa aggiunta influisce sulle tre stringhe di formato standard seguenti:
Stringa di formato standard "D" (data estesa), che esegue il mapping diretto 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à e ShortTimePattern .
Stringa di formato standard "F" (data completa/ora estesa), che esegue il FullDateTimePattern mapping diretto alla proprietà . Poiché questo valore della proprietà non è stato impostato in modo esplicito, viene generato in modo dinamico concatenando le LongDatePattern proprietà e LongTimePattern .
L'esempio mostra anche come modificare il nome dell'era per le impostazioni cultura il cui calendario ha una singola era. In questo caso, le impostazioni cultura en-US usano il calendario gregoriano, rappresentato da un GregorianCalendar oggetto . La GregorianCalendar classe supporta una singola era, che denomina A.D. (Anno Domini). Nell'esempio il nome dell'era viene modificato in C.E. (Common Era) 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 GetEraName metodo dai dati privati nelle tabelle delle impostazioni cultura fornite da .NET o dal sistema operativo.
using System;
using System.Globalization;
public class Example4
{
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
Analizzare stringhe di data e ora
L'analisi comporta la conversione della rappresentazione di stringa di una data e dell'ora in un DateTime valore o DateTimeOffset . Entrambi questi tipi includono i Parsemetodi , TryParse, ParseExacte TryParseExact per supportare le operazioni di analisi. I Parse metodi e TryParse converteno una stringa che può avere un'ampia gamma di formati, mentre ParseExact e TryParseExact richiedono che la stringa abbia un formato o formati definiti. Se l'operazione di analisi non riesce Parse e ParseExact genera un'eccezione, mentre TryParse e TryParseExact restituisce false.
I metodi di analisi usano in modo implicito o esplicito un DateTimeStyles valore di enumerazione per determinare quali elementi di stile (ad esempio, spazi vuoti iniziali, finali o interni) possono essere presenti nella stringa da analizzare e come interpretare la stringa analizzata o eventuali elementi mancanti. Se non si specifica un DateTimeStyles valore quando si chiama il Parse metodo o TryParse , il valore predefinito è DateTimeStyles.AllowWhiteSpaces, ovvero uno stile composito che include i DateTimeStyles.AllowLeadingWhiteflag , DateTimeStyles.AllowTrailingWhitee DateTimeStyles.AllowInnerWhite . Per i ParseExact metodi e TryParseExact , il valore predefinito è DateTimeStyles.None. La stringa di input deve corrispondere esattamente a una determinata stringa di formato di data e ora personalizzata.
I metodi di analisi usano anche in modo implicito o esplicito un DateTimeFormatInfo oggetto che definisce i simboli e i modelli specifici che possono verificarsi nella stringa da analizzare. Se non si specifica un DateTimeFormatInfo oggetto , l'oggetto DateTimeFormatInfo per le impostazioni cultura correnti viene utilizzato per impostazione predefinita. Per altre informazioni sull'analisi di stringhe di data e ora, vedere i singoli metodi di analisi, ad esempio DateTime.Parse, DateTime.TryParseDateTimeOffset.ParseExact, e DateTimeOffset.TryParseExact.
Nell'esempio seguente viene illustrata la natura sensibile alle 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 FormatException nelle altre tre impostazioni cultura perché 18 viene interpretato come numero del mese. 1/2/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 ParseEx1
{
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
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; ovvero per deserializzare un valore di data e ora precedentemente serializzato come stringa.
Le sezioni seguenti illustrano in modo più dettagliato queste due operazioni.
Analizzare le stringhe utente
Quando si analizzano le stringhe di data e ora immesse dall'utente, è consigliabile creare sempre un'istanza di un DateTimeFormatInfo oggetto che rifletta le impostazioni culturali dell'utente, incluse eventuali personalizzazioni che l'utente può aver apportato. In caso contrario, l'oggetto data e ora potrebbe avere valori non corretti. Per informazioni su come creare un'istanza di un DateTimeFormatInfo oggetto che riflette le personalizzazioni cultura dell'utente, vedere la sezione DateTimeFormatInfo e dati dinamici.
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 geografica e lingua per modificare il modello di data breve da "M/d/aaaa" a "yy/MM/dd". Quando l'utente immette una stringa che riflette le impostazioni utente e la stringa viene analizzata da un DateTimeFormatInfo oggetto che riflette anche le impostazioni utente (sostituzioni), l'operazione di analisi restituisce un risultato corretto. Tuttavia, quando la stringa viene analizzata da un DateTimeFormatInfo oggetto che riflette le impostazioni cultura standard en-US, il metodo di analisi genera un'eccezione FormatException perché interpreta 14 come numero del mese, non le ultime due cifre dell'anno.
using System;
using System.Globalization;
public class ParseEx2
{
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
Serializzare e deserializzare i dati di data e ora
I dati di data e ora serializzati sono previsti round trip; ovvero, tutti i valori serializzati e deserializzati devono essere identici. Se un valore di data e ora rappresenta un singolo momento nel tempo, il valore deserializzato deve rappresentare lo stesso momento nel tempo 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 InvariantInfo proprietà , per generare e analizzare 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 è strettamente 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 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 temporali 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 SerializeEx1
{
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)
Deserializza i dati su un sistema a Bruxelles, Copenaghen, Madrid e Parigi fuso orario e la cui cultura attuale è fr-FR. La data ripristinata è di nove ore dopo la data originale, che riflette la rettifica del fuso orario da otto ore dietro l'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 SerializeEx2
{
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
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per