Stringhe di formato DateTime personalizzato
Una stringa di formato DateTime personalizzato è costituita da uno o più identificatori di formato DateTime personalizzato e definisce la rappresentazione di testo di un oggetto DateTime derivante da un'operazione di formattazione. Qualsiasi stringa che non è una stringa di formato DateTime standard viene interpretata come stringa di formato DateTime personalizzato.
Identificatori di formato DateTime personalizzato
Nella tabella riportata di seguito vengono descritti gli identificatori di formato DateTime personalizzato. Per gli esempi dell'output prodotto da ogni identificatore di formato, vedere Esempi di output di stringhe di formato DateTime personalizzato.
| Identificatore di formato | Descrizione |
|---|---|
d |
Rappresenta il giorno del mese come numero compreso tra 1 e 31. I giorni costituiti da una singola cifra vengono formattati senza zero iniziale. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
dd |
Rappresenta il giorno del mese come numero compreso tra 01 e 31. I giorni costituiti da una singola cifra vengono formattati con uno zero iniziale. |
ddd |
Rappresenta il nome abbreviato del giorno della settimana come definito nella proprietà System.Globalization.DateTimeFormatInfo.AbbreviatedDayNames corrente. |
dddd (più un numero qualsiasi di identificatori "d" aggiuntivi) |
Rappresenta il nome completo del giorno della settimana come definito nella proprietà System.Globalization.DateTimeFormatInfo.DayNames corrente. |
f |
Rappresenta la cifra più significativa della frazione di secondi. Se viene utilizzato da solo, senza altri identificatori di formato, l'identificatore di formato "f" viene interpretato come identificatore di formato DateTime standard "f" (schema di data/ora completo). Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. Se si utilizza questo identificatore di formato con il metodo ParseExact o TryParseExact, il numero di identificatori di formato "f" utilizzato indica il numero delle cifre più significative della frazione di secondi da analizzare. |
ff |
Rappresenta le due cifre più significative della frazione di secondi. |
fff |
Rappresenta le tre cifre più significative della frazione di secondi. |
ffff |
Rappresenta le quattro cifre più significative della frazione di secondi. |
fffff |
Rappresenta le cinque cifre più significative della frazione di secondi. |
ffffff |
Rappresenta le sei cifre più significative della frazione di secondi. |
fffffff |
Rappresenta le sette cifre più significative della frazione di secondi. |
F |
Rappresenta la cifra più significativa della frazione di secondi. Se la cifra è zero, non viene prodotta alcuna visualizzazione. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. Se si utilizza questo identificatore di formato con il metodo ParseExact o TryParseExact, il numero di identificatori di formato "F" utilizzato indica il numero massimo delle cifre più significative della frazione di secondi da analizzare. |
FF |
Rappresenta le due cifre più significative della frazione di secondi. Gli zeri finali, o le cifre con due zeri, non vengono visualizzati. |
FFF |
Rappresenta le tre cifre più significative della frazione di secondi. Gli zeri finali, o le cifre con tre zeri, non vengono visualizzati. |
FFFF |
Rappresenta le quattro cifre più significative della frazione di secondi. Gli zeri finali, o le cifre con quattro zeri, non vengono visualizzati. |
FFFFF |
Rappresenta le cinque cifre più significative della frazione di secondi. Gli zeri finali, o le cifre con cinque zeri, non vengono visualizzati. |
FFFFFF |
Rappresenta le sei cifre più significative della frazione di secondi. Gli zeri finali, o le cifre con sei zeri, non vengono visualizzati. |
FFFFFFF |
Rappresenta le sette cifre più significative della frazione di secondi. Gli zeri finali, o le cifre con sette zeri, non vengono visualizzati. |
g o gg (più un numero qualsiasi di identificatori "g" aggiuntivi) |
Rappresenta il periodo o l'era, ad esempio d.C. Questo identificatore viene ignorato se la data da formattare non è associata a una stringa di periodo o di era. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
h |
Rappresenta l'ora come numero compreso tra 1 e 12, ovvero l'ora rappresentata nel formato delle 12 ore in base al quale il conteggio riparte da mezzanotte o da mezzogiorno. Di conseguenza, una particolare ora dopo mezzanotte è indistinguibile dalla stessa ora dopo mezzogiorno. L'ora non viene arrotondata e se è costituita da una singola cifra viene formattata senza zero iniziale. Per un valore 5:43 ad esempio questo identificatore di formato visualizza "5". Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
hh, hh (più un numero qualsiasi di identificatori "h" aggiuntivi) |
Rappresenta l'ora come numero compreso tra 01 e 12, ovvero l'ora rappresentata nel formato delle 12 ore in base al quale il conteggio riparte da mezzanotte o da mezzogiorno. Di conseguenza, una particolare ora dopo mezzanotte è indistinguibile dalla stessa ora dopo mezzogiorno. L'ora non viene arrotondata e se è costituita da una singola cifra viene formattata con uno zero iniziale. Per un valore 5:43 ad esempio questo identificatore di formato visualizza "05". |
H |
Rappresenta l'ora come numero compreso tra 0 e 23, ovvero l'ora rappresentata nel formato delle 24 ore in base zero in cui il conteggio parte da mezzanotte. Un'ora costituita da una singola cifra viene formattata senza zero iniziale. |
HH, HH (più un numero qualsiasi di identificatori "H" aggiuntivi) |
Rappresenta l'ora come numero compreso tra 00 e 23, ovvero l'ora rappresentata nel formato delle 24 ore in base zero in cui il conteggio parte da mezzanotte. Un'ora costituita da una singola cifra viene formattata con uno zero iniziale. |
K |
Rappresenta valori diversi della proprietà DateTime.Kind, ovvero Local, Utc o Unspecified. Questo identificatore recupera il valore Kind e lo rende in formato di testo mantenendo il fuso orario. Per il valore Kind di tipo Local, questo identificatore equivale all'identificatore "zzz" e visualizza lo scarto locale, ad esempio "-07: 00". Per il valore Kind di tipo Utc, l'identificatore visualizza un carattere "Z" per rappresentare una data UTC. Per il valore Kind di tipo Unspecified, l'identificatore equivale a "" (nessun valore). |
m |
Rappresenta il minuto come numero compreso tra 0 e 59. Il minuto rappresenta minuti interi trascorsi dall'ultima ora. Un minuto costituito da una singola cifra viene formattato senza zero iniziale. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
mm, mm (più un numero qualsiasi di identificatori "m" aggiuntivi) |
Rappresenta il minuto come numero compreso tra 0 e 59. Il minuto rappresenta minuti interi trascorsi dall'ultima ora. Un minuto costituito da una singola cifra viene formattato con uno zero iniziale. |
M |
Rappresenta il mese come numero compreso tra 1 e 12. Un mese costituito da una singola cifra viene formattato senza zero iniziale. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
MM |
Rappresenta il mese come numero compreso tra 01 e 12. Un mese costituito da una singola cifra viene formattato con uno zero iniziale. |
MMM |
Rappresenta il nome abbreviato del mese come definito nella proprietà System.Globalization.DateTimeFormatInfo.AbbreviatedMonthNames corrente. |
MMMM |
Rappresenta il nome completo del mese come definito nella proprietà System.Globalization.DateTimeFormatInfo.MonthNames corrente. |
s |
Rappresenta i secondi come numero compreso tra 0 e 59. Il secondo rappresenta secondi interi trascorsi dall'ultimo minuto. Un secondo costituito da una singola cifra viene formattato senza zero iniziale. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
ss, ss (più un numero qualsiasi di identificatori "s" aggiuntivi) |
Rappresenta i secondi come numero compreso tra 00 e 59. Il secondo rappresenta secondi interi trascorsi dall'ultimo minuto. Un secondo costituito da una singola cifra viene formattato con uno zero iniziale. |
t |
Rappresenta il primo carattere dell'indicatore A.M./P.M. definito nella proprietà System.Globalization.DateTimeFormatInfo.AMDesignator o System.Globalization.DateTimeFormatInfo.PMDesignator corrente. L'indicatore A.M. viene utilizzato se l'ora da formattare è minore di 12, altrimenti viene utilizzato l'indicatore P.M. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
tt, tt (più un numero qualsiasi di identificatori "t" aggiuntivi) |
Rappresenta l'indicatore A.M./P.M. come definito nella proprietà System.Globalization.DateTimeFormatInfo.AMDesignator o System.Globalization.DateTimeFormatInfo.PMDesignator corrente. L'indicatore A.M. viene utilizzato se l'ora da formattare è minore di 12, altrimenti viene utilizzato l'indicatore P.M. |
y |
Rappresenta l'anno con al massimo un numero a due cifre. Se l'anno ha più di due cifre, nel risultato vengono visualizzate solo le due cifre di ordine inferiore. Se l'anno ha meno di due cifre, il numero viene formattato senza zero iniziale. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
yy |
Rappresenta l'anno come numero a due cifre. Se l'anno ha più di due cifre, nel risultato vengono visualizzate solo le due cifre di ordine inferiore. Se l'anno ha meno di due cifre, al numero vengono anteposti tanti zeri quanto sono necessari per ottenere due cifre. |
yyy |
Rappresenta l'anno come numero a tre cifre. Se l'anno ha più di tre cifre, nel risultato vengono visualizzate solo le tre cifre di ordine inferiore. Se l'anno ha meno di tre cifre, al numero vengono anteposti tanti zeri quanti sono necessari per ottenere tre cifre. Per il calendario buddista tailandese, in cui sono previsti anni di cinque cifre, questo identificatore di formato visualizza tutte e cinque le cifre. |
yyyy |
Rappresenta l'anno come numero a quattro cifre. Se l'anno ha più di quattro cifre, nel risultato vengono visualizzate solo le quattro cifre di ordine inferiore. Se l'anno ha meno di quattro cifre, al numero vengono anteposti tanti zeri quanto sono necessari per ottenere quattro cifre. Per il calendario buddista tailandese, in cui sono previsti anni di cinque cifre, questo identificatore di formato visualizza tutte e cinque le cifre. |
yyyyy (più un numero qualsiasi di identificatori "y" aggiuntivi) |
Rappresenta l'anno come numero a cinque cifre. Se l'anno ha più di cinque cifre, nel risultato vengono visualizzate solo le cinque cifre di ordine inferiore. Se l'anno ha meno di cinque cifre, al numero vengono anteposti tanti zeri quanto sono necessari per ottenere cinque cifre. Se esistono ulteriori identificatori "y", al numero vengono anteposti tanti zeri quanti sono necessari per ottenere il numero di identificatori "y". |
z |
Rappresenta lo scarto di fuso orario con segno tra il sistema in uso e l'ora di Greenwich (GMT) misurato in ore. Lo scarto per un computer nel fuso orario del Pacifico (ora solare) ad esempio è "-8". Lo scarto viene visualizzato sempre con un segno iniziale. Un segno più (+) indica che le ore sono in più rispetto all'ora di Greenwich e un segno meno (-) indica che le ore sono in meno rispetto all'ora di Greenwich. Lo scarto può essere compreso tra -12 e +13. Uno scarto costituito da una singola cifra viene formattato senza zero iniziale. Lo scarto è influenzato dall'ora solare. Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
zz |
Rappresenta lo scarto di fuso orario con segno tra il sistema in uso e l'ora di Greenwich (GMT) misurato in ore. Lo scarto per un computer nel fuso orario del Pacifico (ora solare) ad esempio è "-08". Lo scarto viene visualizzato sempre con un segno iniziale. Un segno più (+) indica che le ore sono in più rispetto all'ora di Greenwich e un segno meno (-) indica che le ore sono in meno rispetto all'ora di Greenwich. Lo scarto può essere compreso tra -12 e +13. Uno scarto costituito da una singola cifra viene formattato con uno zero iniziale. Lo scarto è influenzato dall'ora solare. |
zzz, zzz (più un numero qualsiasi di identificatori "z" aggiuntivi) |
Rappresenta lo scarto di fuso orario con segno tra il sistema in uso e l'ora di Greenwich (GMT) misurato in ore e minuti. Lo scarto per un computer nel fuso orario del Pacifico (ora solare) ad esempio è "-08:00". Lo scarto viene visualizzato sempre con un segno iniziale. Un segno più (+) indica che le ore sono in più rispetto all'ora di Greenwich e un segno meno (-) indica che le ore sono in meno rispetto all'ora di Greenwich. Lo scarto può essere compreso tra -12 e +13. Uno scarto costituito da una singola cifra viene formattato con uno zero iniziale. Lo scarto è influenzato dall'ora solare. |
: |
Separatore dell'ora definito nella proprietà System.Globalization.DateTimeFormatInfo.TimeSeparator corrente utilizzato per differenziare ore, minuti e secondi. |
/ |
Separatore della data definito nella proprietà System.Globalization.DateTimeFormatInfo.DateSeparator corrente utilizzato per differenziare anni, mesi e giorni. |
" |
Stringa tra virgolette. Visualizza il valore letterale di una stringa tra due virgolette ("). Anteporre a ogni virgoletta un carattere di escape (\). |
' |
Stringa tra virgolette singole. Visualizza il valore letterale di una stringa tra virgolette singole ('). |
%c |
Rappresenta il risultato associato a un identificatore di formato personalizzato "c", quando la stringa di formato DateTime personalizzato è costituita unicamente da tale identificatore di formato personalizzato. Per utilizzare pertanto l'identificatore di formato personalizzato "d", "f", "F", "h", "m", "s", "t", "y", "z", "H" o "M" da solo, specificare "%d", "%f", "%F", "%h", "%m", "%s", "%t", "%y", "%z", "%H" o "%M". Per ulteriori informazioni sull'utilizzo di un solo identificatore di formato, vedere Utilizzo di singoli identificatori di formato personalizzato. |
\c |
Carattere di escape. Visualizza il carattere "c" come carattere letterale se il carattere è preceduto dal carattere di escape (\). Per inserire il carattere di barra rovesciata nella stringa risultato, utilizzare due caratteri di escape ("\\"). |
Qualsiasi altro carattere |
Gli altri caratteri vengono copiati nella stringa risultato e non influiscono sulla formattazione. |
Impostazioni del Pannello di controllo
Le impostazioni di Opzioni internazionali e della lingua nel Pannello di controllo influiscono sulla stringa risultato prodotta da un'operazione di formattazione. Queste impostazioni vengono utilizzate per inizializzare l'oggetto DateTimeFormatInfo associato alla lingua del thread corrente e la lingua del thread corrente fornisce i valori utilizzati per definire la formattazione. Computer con impostazioni diverse generano stringhe di risultati diverse.
Proprietà DateTimeFormatInfo
La formattazione è influenzata dalle proprietà dell'oggetto DateTimeFormatInfo corrente, che viene fornito in modo implicito dalla lingua del thread corrente o in modo esplicito dal parametro IFormatProvider del metodo che richiama la formattazione. Specificare per il parametro IFormatProvider un oggetto CultureInfo, che rappresenta una lingua, o un oggetto DateTimeFormatInfo.
Molti degli identificatori di formato DateTime standard sono alias di modelli di formattazione definiti da proprietà dell'oggetto DateTimeFormatInfo corrente. Questo significa che è possibile modificare il risultato prodotto da alcuni identificatori di formato DateTime standard modificando la proprietà DateTimeFormatInfo corrispondente.
Utilizzo di singoli identificatori di formato personalizzato
Una stringa di formato DateTime personalizzato è costituita da due o più caratteri. Se ad esempio la stringa di formato è costituita solo dall'identificatore "h", la stringa di formato viene interpretata come stringa di formato DateTime standard. In questo caso specifico tuttavia viene generata un'eccezione perché non esiste alcun identificatore di formato DateTime standard "h".
Per utilizzare un identificatore di formato DateTime personalizzato, includere uno spazio prima o dopo l'identificatore DateTime oppure includere un identificatore di formato percentuale (%) prima dell'identificatore DateTime. Le stringhe di formato "h" e "% h" ad esempio vengono interpretate come stringhe di formato DateTime personalizzato che visualizzano l'ora rappresentata dall'oggetto DateTime corrente. Se viene utilizzato uno spazio, questo verrà visualizzato come carattere letterale nella stringa risultato.
Utilizzo delle stringhe di formato personalizzato
Nel frammento di codice riportato di seguito viene illustrato come creare da un oggetto DateTime stringhe formattate personalizzate. L'esempio si basa sul presupposto che la lingua corrente sia l'inglese degli Stati Uniti (en-US).
Dim MyDate As New DateTime(2000, 1, 1, 0, 0, 0)
Dim MyString As String = MyDate.ToString("dddd - d - MMMM")
' In the U.S. English culture, MyString has the value:
' "Saturday - 1 - January".
MyString = MyDate.ToString("yyyy gg")
' In the U.S. English culture, MyString has the value: "2000 A.D.".
DateTime MyDate = new DateTime(2000, 1, 1, 0, 0, 0);
String MyString = MyDate.ToString("dddd - d - MMMM");
// In the U.S. English culture, MyString has the value:
// "Saturday - 1 - January".
MyString = MyDate.ToString("yyyy gg");
// In the U.S. English culture, MyString has the value: "2000 A.D.".
Esempio
Nell'esempio di codice riportato di seguito viene illustrato il risultato prodotto da ciascun identificatore di formato DateTime personalizzato.
' This code example demonstrates the result yielded by each custom
' DateTime format specifier.
Imports System
Imports System.Globalization
Class Sample
Public Shared Sub Main()
Dim formatString As String
Dim ci As New CultureInfo("")
Dim msgDTctor As String = "The DateTime constructor for " & _
"January 3, 0001 A.D., 02:09:20.444 P.M. is" & vbLf & _
" DateTime(0001, 1, 3, 14, 9, 20, 444)" & vbLf
Dim thisDate As New DateTime(1, 1, 3, 14, 9, 20, 444)
Dim utcDate As New DateTime(0002, 2, 4, 15, 10, 21, 555, DateTimeKind.Utc)
Dim localDate As New DateTime(0003, 3, 5, 16, 11, 22, 666, DateTimeKind.Local)
' Custom DateTime format specifiers.
' The specifiers are for year, month, day, era, hour, minute, second, fraction of a second,
' A.M./P.M. designator, UTC offset, quoted string (apostrophe), quoted string (quotation mark),
' and escape character.
Dim specifiers As String() = New String() { _
"%y", "yy", "yyy", "yyyy", "yyyyy", _
"%M", "MM", "MMM", "MMMM", _
"%d", "dd", "ddd", "dddd", _
"%g", "gg", _
"%h", "hh", "%H", "HH", _
"%m", "mm", _
"%s", "ss", _
"%f", "ff", "fff", "ffff", "fffff", "ffffff", "fffffff", _
"%F", "FF", "FFF", "FFFF", "FFFFF", "FFFFFF", "FFFFFFF", _
"%t", "tt", _
"%z", "zz", "zzz", _
"'The year is' yyyy", _
"""The year is"" yyyy", _
"\\"}
Console.Clear()
Console.WriteLine("The culture is {0}.", ci.DisplayName)
Console.WriteLine(msgDTctor)
Console.WriteLine("{0,20} {1}", "Custom format string", "Yields")
Console.WriteLine("{0,20} {1}", "--------------------", "------")
Dim format As String
For Each format In specifiers
formatString = """" & format & """"
Console.WriteLine("{0,20} ""{1}""", formatString, thisDate.ToString(format))
Next format
Console.WriteLine()
Console.WriteLine()
' Example of using "K" format specifier.
Console.WriteLine("Format different kinds of DateTime using ""K""")
Console.WriteLine("{0, 20} {1}", "DateTimeKind", "Yields")
Console.WriteLine("{0,20} {1}", "------------", "------")
Console.WriteLine("{0,20} ""{1}""", thisDate.Kind, thisDate.ToString("%K"))
Console.WriteLine("{0,20} ""{1}""", utcDate.Kind, utcDate.ToString("%K"))
Console.WriteLine("{0,20} ""{1}""", localDate.Kind, localDate.ToString("%K"))
End Sub 'Main
End Class 'Sample
'This code example produces the following results:
'
'The culture is Invariant Language (Invariant Country).
'The DateTime constructor for January 3, 0001 A.D., 02:09:20.444 P.M. is
' DateTime(0001, 1, 3, 14, 9, 20, 444)
'
'Custom format string Yields
'-------------------- ------
' "%y" "1"
' "yy" "01"
' "yyy" "001"
' "yyyy" "0001"
' "yyyyy" "00001"
' "%M" "1"
' "MM" "01"
' "MMM" "Jan"
' "MMMM" "January"
' "%d" "3"
' "dd" "03"
' "ddd" "Wed"
' "dddd" "Wednesday"
' "%g" "A.D."
' "gg" "A.D."
' "%h" "2"
' "hh" "02"
' "%H" "14"
' "HH" "14"
' "%m" "9"
' "mm" "09"
' "%s" "20"
' "ss" "20"
' "%f" "4"
' "ff" "44"
' "fff" "444"
' "ffff" "4440"
' "fffff" "44400"
' "ffffff" "444000"
' "fffffff" "4440000"
' "%F" "4"
' "FF" "44"
' "FFF" "444"
' "FFFF" "444"
' "FFFFF" "444"
' "FFFFFF" "444"
' "FFFFFFF" "444"
' "%t" "P"
' "tt" "PM"
' "%z" "-8"
' "zz" "-08"
' "zzz" "-08:00"
'"'The year is' yyyy" "The year is 0001"
'""The year is" yyyy" "The year is 0001"
' "\\" "\"
'
'
'Format different kinds of DateTime using "K"
' DateTimeKind Yields
' ------------ ------
' Unspecified ""
' Utc "Z"
' Local "-08:00"
// This code example demonstrates the result yielded by each custom
// DateTime format specifier.
using System;
using System.Globalization;
class Sample
{
public static void Main()
{
string formatString;
CultureInfo ci = new CultureInfo("");
string msgDTctor = "The DateTime constructor for " +
"January 3, 0001 A.D., 02:09:20.444 P.M. is\n" +
" DateTime(0001, 1, 3, 14, 9, 20, 444)\n";
DateTime thisDate = new DateTime(0001, 1, 3, 14, 9, 20, 444); // This is equal to DateTime thisDate = new DateTime(0001, 1, 3, 14, 9, 20, 444, DateTime.Unspecified)
DateTime utcDate = new DateTime(0002, 2, 4, 15, 10, 21, 555, DateTimeKind.Utc);
DateTime localDate = new DateTime(0003, 3, 5, 16, 11, 22, 666, DateTimeKind.Local);
// Custom DateTime format specifiers
string[] specifiers = {
// Year
"%y",
"yy",
"yyy",
"yyyy",
"yyyyy",
// Month
"%M",
"MM",
"MMM",
"MMMM",
// Day
"%d",
"dd",
"ddd",
"dddd",
// Era
"%g",
"gg",
// Hour
"%h",
"hh",
"%H",
"HH",
// Minute
"%m",
"mm",
// Second
"%s",
"ss",
// Fraction of a second
"%f",
"ff",
"fff",
"ffff",
"fffff",
"ffffff",
"fffffff",
"%F",
"FF",
"FFF",
"FFFF",
"FFFFF",
"FFFFFF",
"FFFFFFF",
// A.M./P.M. designator
"%t",
"tt",
// UTC offset
"%z",
"zz",
"zzz",
// Quoted string (apostrophe)
"'The year is' yyyy",
// Quoted string (quotation mark)
"\"The year is\" yyyy",
// Escape character
@"\\",
};
//
Console.Clear();
Console.WriteLine("The culture is {0}.", ci.DisplayName);
Console.WriteLine(msgDTctor);
Console.WriteLine("{0,20} {1}", "Custom format string", "Yields");
Console.WriteLine("{0,20} {1}", "--------------------", "------");
foreach (string format in specifiers)
{
formatString = "\"" + format + "\"";
Console.WriteLine("{0,20} \"{1}\"",
formatString, thisDate.ToString(format));
}
Console.WriteLine();
Console.WriteLine();
// Example of using "K" format specifier.
Console.WriteLine("Format different kinds of DateTime using \"K\"");
Console.WriteLine("{0, 20} {1}", "DateTimeKind", "Yields");
Console.WriteLine("{0,20} {1}", "------------", "------");
Console.WriteLine("{0,20} \"{1}\"", thisDate.Kind, thisDate.ToString("%K"));
Console.WriteLine("{0,20} \"{1}\"", utcDate.Kind, utcDate.ToString("%K"));
Console.WriteLine("{0,20} \"{1}\"", localDate.Kind, localDate.ToString("%K"));
}
}
/*
This code example produces the following results:
The culture is Invariant Language (Invariant Country).
The DateTime constructor for January 3, 0001 A.D., 02:09:20.444 P.M. is
DateTime(0001, 1, 3, 14, 9, 20, 444)
Custom format string Yields
-------------------- ------
"%y" "1"
"yy" "01"
"yyy" "001"
"yyyy" "0001"
"yyyyy" "00001"
"%M" "1"
"MM" "01"
"MMM" "Jan"
"MMMM" "January"
"%d" "3"
"dd" "03"
"ddd" "Wed"
"dddd" "Wednesday"
"%g" "A.D."
"gg" "A.D."
"%h" "2"
"hh" "02"
"%H" "14"
"HH" "14"
"%m" "9"
"mm" "09"
"%s" "20"
"ss" "20"
"%f" "4"
"ff" "44"
"fff" "444"
"ffff" "4440"
"fffff" "44400"
"ffffff" "444000"
"fffffff" "4440000"
"%F" "4"
"FF" "44"
"FFF" "444"
"FFFF" "444"
"FFFFF" "444"
"FFFFFF" "444"
"FFFFFFF" "444"
"%t" "P"
"tt" "PM"
"%z" "-8"
"zz" "-08"
"zzz" "-08:00"
"'The year is' yyyy" "The year is 0001"
""The year is" yyyy" "The year is 0001"
"\\" "\"
Format different kinds of DateTime using "K"
DateTimeKind Yields
------------ ------
Unspecified ""
Utc "Z"
Local "-08:00"
*/
// This code example demonstrates the result yielded by each custom
// DateTime format specifier.
using namespace System;
using namespace System::Globalization;
int main()
{
String^ formatString;
CultureInfo^ ci = gcnew CultureInfo("");
String^ msgDTctor = "The DateTime constructor for "
"January 3, 0001 A.D., 02:09:20.444 P.M. is\n"
" DateTime(0001, 1, 3, 14, 9, 20, 444)\n";
DateTime^ thisDate = gcnew DateTime(0001, 1, 3, 14, 9, 20, 444);
DateTime^ utcDate = gcnew DateTime(0002, 2, 4, 15, 10, 21, 555, DateTimeKind::Utc);
DateTime^ localDate = gcnew DateTime(0003, 3, 5, 16, 11, 22, 666, DateTimeKind::Local);
// Custom DateTime format specifiers
array<String^>^ specifiers = gcnew array<String^> {
// Year
"%y",
"yy",
"yyy",
"yyyy",
"yyyyy",
// Month
"%M",
"MM",
"MMM",
"MMMM",
// Day
"%d",
"dd",
"ddd",
"dddd",
// Era
"%g",
"gg",
// Hour
"%h",
"hh",
"%H",
"HH",
// Minute
"%m",
"mm",
// Second
"%s",
"ss",
// Fraction of a second
"%f",
"ff",
"fff",
"ffff",
"fffff",
"ffffff",
"fffffff",
"%F",
"FF",
"FFF",
"FFFF",
"FFFFF",
"FFFFFF",
"FFFFFFF",
// A.M./P.M. designator
"%t",
"tt",
// UTC offset
"%z",
"zz",
"zzz",
// Quoted string (apostrophe)
"'The year is' yyyy",
// Quoted string (quotation mark)
"\"The year is\" yyyy",
// Escape character
"\\\\",
};
//
Console::Clear();
Console::WriteLine("The culture is {0}.", ci->DisplayName);
Console::WriteLine(msgDTctor);
Console::WriteLine("{0,20} {1}", "Custom format string", "Yields");
Console::WriteLine("{0,20} {1}", "--------------------", "------");
for each (String^ format in specifiers)
{
formatString = "\"" + format + "\"";
Console::WriteLine("{0,20} \"{1}\"",
formatString, thisDate->ToString(format));
}
Console::WriteLine();
Console::WriteLine();
// Example of using "K" format specifier.
Console::WriteLine("Format different kinds of DateTime using \"K\"");
Console::WriteLine("{0, 20} {1}", "DateTimeKind", "Yields");
Console::WriteLine("{0,20} {1}", "------------", "------");
Console::WriteLine("{0,20} \"{1}\"", thisDate->Kind, thisDate->ToString("%K"));
Console::WriteLine("{0,20} \"{1}\"", utcDate->Kind, utcDate->ToString("%K"));
Console::WriteLine("{0,20} \"{1}\"", localDate->Kind, localDate->ToString("%K"));
}
/*
This code example produces the following results:
The culture is Invariant Language (Invariant Country).
The DateTime constructor for January 3, 0001 A.D., 02:09:20.444 P.M. is
DateTime(0001, 1, 3, 14, 9, 20, 444)
Custom format string Yields
-------------------- ------
"%y" "1"
"yy" "01"
"yyy" "001"
"yyyy" "0001"
"yyyyy" "00001"
"%M" "1"
"MM" "01"
"MMM" "Jan"
"MMMM" "January"
"%d" "3"
"dd" "03"
"ddd" "Wed"
"dddd" "Wednesday"
"%g" "A.D."
"gg" "A.D."
"%h" "2"
"hh" "02"
"%H" "14"
"HH" "14"
"%m" "9"
"mm" "09"
"%s" "20"
"ss" "20"
"%f" "4"
"ff" "44"
"fff" "444"
"ffff" "4440"
"fffff" "44400"
"ffffff" "444000"
"fffffff" "4440000"
"%F" "4"
"FF" "44"
"FFF" "444"
"FFFF" "444"
"FFFFF" "444"
"FFFFFF" "444"
"FFFFFFF" "444"
"%t" "P"
"tt" "PM"
"%z" "-8"
"zz" "-08"
"zzz" "-08:00"
"'The year is' yyyy" "The year is 0001"
""The year is" yyyy" "The year is 0001"
"\\" "\"
Format different kinds of DateTime using "K"
DateTimeKind Yields
------------ ------
Unspecified ""
Utc "Z"
Local "-08:00"
*/
Vedere anche
Riferimenti
System.DateTime
System.IFormatProvider
Concetti
Esempi di output di stringhe di formato DateTime personalizzato
Stringhe di formato DateTime standard