Condividi tramite


Stringhe di formato data e ora standard

Una stringa di formato di data e ora standard usa un singolo carattere come identificatore di formato per definire la rappresentazione testuale di un DateTimevalore , DateTimeOffset, DateOnlyo TimeOnly . Qualsiasi stringa di formato di data e ora che contiene più di un carattere, incluso lo spazio vuoto, viene interpretata come una stringa di formato di data e ora personalizzata. Una stringa di formato standard o personalizzata può essere usata in due modi:

  • Per definire la stringa risultante da un'operazione di formattazione.

  • Per definire la rappresentazione testuale di un valore di data e ora che può essere convertito in un DateTimevalore , DateTimeOffset, DateOnlyo TimeOnly da un'operazione di analisi.

Suggerimento

È possibile scaricare Utilità formattazione, un'applicazione Windows Form .NET che consente di applicare stringhe di formato a valori numerici o di data e ora e visualizzare la stringa di risultato. Il codice sorgente è disponibile per C# e Visual Basic.

Tabella degli identificatori di formato

Nella tabella seguente vengono descritti gli identificatori di formato di data e ora standard. Se non diversamente specificato, un particolare identificatore di formato di data e ora standard produce una rappresentazione di stringa identica indipendentemente dal fatto che venga usato con un DateTime valore o .DateTimeOffset Non tutti gli identificatori di formato possono essere usati con DateOnly i valori e TimeOnly . Per altre informazioni, vedere Formattazione DateOnly e TimeOnly. Per informazioni su come le impostazioni internazionali in Windows e l'oggetto corrente DateTimeFormatInfo possono influire sulla formattazione di data e ora, vedere Impostazioni del Pannello di controllo e Proprietà DateTimeFormatInfo.

Identificatore di formato Description Esempi
"d" Modello di data breve.

Altre informazioni:Identificatore di formato data breve ("d").
2009-06-15T13:45:30 -> 15/6/2009 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 (fr-FR)

2009-06-15T13:45:30 -> 2009/06/15 (ja-JP)

DateOnly (2009-06-15) -> 15/6/2009 (en-US)
"D" Modello di data estesa.

Altre informazioni:Identificatore di formato data estesa ("D").
2009-06-15T13:45:30 -> Lunedì, 15 giugno 2009 (en-US)

2009-06-15T13:45:30 -> понедельник, 15 июня 2009 г. (ru-RU)

2009-06-15T13:45:30 -> Lunedì, 15. Juni 2009 (de-DE)
"f" Modello di data/ora completo (ora breve).

Altre informazioni: identificatore di formato di data breve ("f") di data completa.
2009-06-15T13:45:30 -> Lunedì, 15 giugno 2009 1:45 (en-US)

2009-06-15T13:45:30 -> il 15 giugno 2009 13:45 (sv-SE)

2009-06-15T13:45:30 -> Ιεατιρα, 15 Ιοιτοι 2009 1:45 μμ (el-GR)
"F" Modello di data/ora completo (long time).

Altre informazioni: identificatore di formato di data estesa ("F").
2009-06-15T13:45:30 -> Lunedì, 15 giugno 2009 1:45:30 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45:30 (sv-SE)

2009-06-15T13:45:30 -> Ιεατιρα, 15 Ιοτοτοι 2009 1:45:30 μμ (el-GR)
"g" Modello di data/ora generale (ora breve).

Altre informazioni: Identificatore di formato di data breve ("g") generale.
2009-06-15T13:45:30 -> 15/06/2009 1:45 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45 (es-ES)

2009-06-15T13:45:30 -> 15/06/2009 13:45 (zh-CN)
"G" Modello di data/ora generale (long time).

Altre informazioni: identificatore di formato di data estesa generale ("G").
2009-06-15T13:45:30 -> 15/6/2009 1:45:30 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45:30 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45:30 (zh-CN)
"M", "m" Modello mese/giorno.

Altre informazioni: Identificatore di formato mese ("M", "m").
2009-06-15T13:45:30 -> 15 giugno (en-US)

2009-06-15T13:45:30 -> 15. giugno (da-DK)

2009-06-15T13:45:30 -> 15 Juni (id-ID)
"O", "o" modello di data/ora round trip.

Altre informazioni: identificatore di formato round trip ("O", "o").
DateTime valori:

2009-06-15T13:45:30 (DateTimeKind.Local) --> 2009-06-15T13:45:30.0000000-07:00

2009-06-15T13:45:30 (DateTimeKind.Utc) --> 2009-06-15T13:45:30.000000Z

2009-06-15T13:45:30 (DateTimeKind.Unspecified) --> 2009-06-15T13:45:30.00000000

DateTimeOffset valori:

2009-06-15T13:45:30-07:00 --> 2009-06-15T13:45:30.0000000-07:00

DateOnly valori:

2009-06-15 --> 2009-06-15

TimeOnly valori:

13:45:30 --> 13:45:30.00000000
"R", "r" RFC1123 modello.

Altre informazioni: identificatore di formato RFC1123 ("R", "r").
DateTimeOffset input: 2009-06-15T13:45:30 -> Lun, 15 Giugno 2009 20:45:30 GMT
DateTime input: 2009-06-15T13:45:30 -> Lun, 15 Giugno 2009 13:45:30 GMT
"s" Modello di data/ora ordinabile.

Altre informazioni: identificatore di formato ordinabile ("s").
2009-06-15T13:45:30 (DateTimeKind.Local) -> 2009-06-15T13:45:30

2009-06-15T13:45:30 (DateTimeKind.Utc) -> 2009-06-15T13:45:30
"t" Modello di tempo breve.

Altre informazioni: identificatore di formato di breve durata ("t").
2009-06-15T13:45:30 -> 1:45 (en-US)

2009-06-15T13:45:30 -> 13:45 (hr-HR)

2009-06-15T13:45:30 -> 01:45 م (ar-EG)

TimeOnly (13:45:30) -> 13:45 (en-US)
"T" Modello di tempo lungo.

Altre informazioni: identificatore di formato "T").
2009-06-15T13:45:30 -> 1:45:30 (en-US)

2009-06-15T13:45:30 -> 13:45:30 (hr-HR)

2009-06-15T13:45:30 -> 01:45:30 PM (ar-EG)

TimeOnly (13:45:30) -> 13:45:30 (en-US)
"u" Modello di data/ora ordinabile universale.

Altre informazioni: identificatore di formato ordinabile universale ("u").
Con un DateTime valore: 2009-06-15T13:45:30 -> 2009-06-15 13:45:30Z

Con un DateTimeOffset valore: 2009-06-15T13:45:30 -> 2009-06-15 20:45:30Z
"U" Modello di data/ora completo universale.

Altre informazioni: identificatore di formato completo universale ("U").
2009-06-15T13:45:30 -> Lunedì, 15 giugno 2009 8:45:30 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 20:45:30 (sv-SE)

2009-06-15T13:45:30 -> Ιεαττα, 15 Ιοιτιοι 2009 8:45:30 μμ (el-GR)
"Y", "y" Modello mese anno.

Altre informazioni: Identificatore di formato mese dell'anno ("Y").
2009-06-15T13:45:30 -> Giugno 2009 (en-US)

2009-06-15T13:45:30 -> giugno 2009 (da-DK)

2009-06-15T13:45:30 -> Juni 2009 (id-ID)
Qualsiasi altro carattere singolo Identificatore sconosciuto. Genera un runtime FormatException.

Funzionamento delle stringhe di formato standard

In un'operazione di formattazione, una stringa di formato standard è semplicemente un alias per una stringa di formato personalizzata. Il vantaggio dell'uso di un alias per fare riferimento a una stringa di formato personalizzata è che, anche se l'alias rimane invariante, la stringa di formato personalizzata può variare. Questo aspetto è importante perché le rappresentazioni di stringa dei valori di data e ora variano in genere in base alle impostazioni cultura. Ad esempio, la stringa di formato standard "d" indica che un valore di data e ora deve essere visualizzato usando un modello di data breve. Per le impostazioni cultura invarianti, questo modello è "MM/gg/aa". Per le impostazioni cultura fr-FR, è "dd/MM/aaaa". Per le impostazioni cultura ja-JP, è "aaaa/MM/gg".

Se una stringa di formato standard in un'operazione di formattazione esegue il mapping alla stringa di formato personalizzata di una determinata cultura, l'applicazione può definire le impostazioni cultura specifiche le cui stringhe di formato personalizzate vengono usate in uno dei modi seguenti:

  • È possibile usare le impostazioni cultura predefinite (o correnti). Nell'esempio seguente viene visualizzata una data utilizzando il formato di data breve delle impostazioni cultura correnti. In questo caso, le impostazioni cultura correnti sono en-US.

    // Display using current (en-us) culture's short date format
    DateTime thisDate = new DateTime(2008, 3, 15);
    Console.WriteLine(thisDate.ToString("d"));           // Displays 3/15/2008
    
    ' Display using current (en-us) culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Console.WriteLine(thisDate.ToString("d"))     ' Displays 3/15/2008
    
  • È possibile passare un CultureInfo oggetto che rappresenta le impostazioni cultura la cui formattazione deve essere utilizzata per un metodo con un IFormatProvider parametro . Nell'esempio seguente viene visualizzata una data utilizzando il formato di data breve delle impostazioni cultura pt-BR.

    // Display using pt-BR culture's short date format
    DateTime thisDate = new DateTime(2008, 3, 15);
    CultureInfo culture = new CultureInfo("pt-BR");
    Console.WriteLine(thisDate.ToString("d", culture));  // Displays 15/3/2008
    
    ' Display using pt-BR culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Dim culture As New CultureInfo("pt-BR")
    Console.WriteLine(thisDate.ToString("d", culture))   ' Displays 15/3/2008
    
  • È possibile passare un DateTimeFormatInfo oggetto che fornisce informazioni di formattazione a un metodo con un IFormatProvider parametro . Nell'esempio seguente viene visualizzata una data utilizzando il formato di data breve di un DateTimeFormatInfo oggetto per le impostazioni cultura hr-HR.

    // Display using date format information from hr-HR culture
    DateTime thisDate = new DateTime(2008, 3, 15);
    DateTimeFormatInfo fmt = (new CultureInfo("hr-HR")).DateTimeFormat;
    Console.WriteLine(thisDate.ToString("d", fmt));      // Displays 15.3.2008
    
    ' Display using date format information from hr-HR culture
    Dim thisDate As Date = #03/15/2008#
    Dim fmt As DateTimeFormatInfo = (New CultureInfo("hr-HR")).DateTimeFormat
    Console.WriteLine(thisDate.ToString("d", fmt))   ' Displays 15.3.2008
    

Annotazioni

Per informazioni sulla personalizzazione dei modelli o delle stringhe usate nella formattazione dei valori di data e ora, vedere l'argomento relativo alla NumberFormatInfo classe.

In alcuni casi, la stringa di formato standard funge da abbreviazione pratica per una stringa di formato personalizzata più lunga che è invariante. Quattro stringhe di formato standard rientrano in questa categoria: "O" (o "o"), "R" (o "r"), "s" e "u". Queste stringhe corrispondono a stringhe di formato personalizzate definite dalle impostazioni cultura invarianti. Producono rappresentazioni di stringa di valori di data e ora che devono essere identici tra le impostazioni cultura. Nella tabella seguente vengono fornite informazioni su queste quattro stringhe di formato di data e ora standard.

Stringa di formato standard Definito dalla proprietà DateTimeFormatInfo.InvariantInfo Stringa di formato personalizzata
"O" o "o" None aaaa'-'MM'-'dd'T'HH':'mm':'ss'.' fffffffK
"R" o "r" RFC1123Pattern ddd, gg MMM aaA HH':'mm':'ss 'GMT'
"s" SortableDateTimePattern Aaaa'-'MM'-'dd'T'HH':'mm':'ss
"u" UniversalSortableDateTimePattern Aaaa'-'MM'-'dd HH':'mm':'ss'Z'

Le stringhe di formato standard possono essere usate anche nelle operazioni di analisi con i DateTime.ParseExactmetodi , DateTimeOffset.ParseExact, DateOnly.ParseExacte TimeOnly.ParseExact , che richiedono che una stringa di input sia esattamente conforme a un modello specifico per l'esito positivo dell'operazione di analisi. Molte stringhe di formato standard eseguono il mapping a più stringhe di formato personalizzate, pertanto un valore di data e ora può essere rappresentato in un'ampia gamma di formati e l'operazione di analisi avrà comunque esito positivo. È possibile determinare la stringa di formato o le stringhe di formato personalizzate che corrispondono a una stringa di formato standard chiamando il DateTimeFormatInfo.GetAllDateTimePatterns(Char) metodo . Nell'esempio seguente vengono visualizzate le stringhe di formato personalizzate mappate alla stringa di formato standard "d" (modello di data breve).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("'d' standard format string:");
      foreach (var customString in DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns('d'))
          Console.WriteLine($"   {customString}");
   }
}
// The example displays the following output:
//       'd' standard format string:
//          M/d/yyyy
//          M/d/yy
//          MM/dd/yy
//          MM/dd/yyyy
//          yy/MM/dd
//          yyyy-MM-dd
//          dd-MMM-yy
Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("'d' standard format string:")
        For Each customString In DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns("d"c)
            Console.WriteLine("   {0}", customString)
        Next
    End Sub
End Module
' The example displays the following output:
'    'd' standard format string:
'       M/d/yyyy
'       M/d/yy
'       MM/dd/yy
'       MM/dd/yyyy
'       yy/MM/dd
'       yyyy-MM-dd
'       dd-MMM-yy

Le sezioni seguenti descrivono gli identificatori di formato standard per DateTimei valori , DateTimeOffsetDateOnly, e TimeOnly .

Formati di data

Questo gruppo include i formati seguenti:

Identificatore di formato data breve ("d")

L'identificatore di formato standard "d" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà delle DateTimeFormatInfo.ShortDatePattern impostazioni cultura specifiche. Ad esempio, la stringa di formato personalizzata restituita dalla ShortDatePattern proprietà delle impostazioni cultura invarianti è "MM/gg/a".

Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che controllano la formattazione della stringa restituita.

Proprietà Description
ShortDatePattern Definisce il formato complessivo della stringa di risultato.
DateSeparator Definisce la stringa che separa i componenti anno, mese e giorno di una data.

Nell'esempio seguente viene usato l'identificatore di formato "d" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008,4, 10);
Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays 4/10/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("en-NZ")));
// Displays 10/04/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("de-DE")));
// Displays 10.04.2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays 4/10/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-NZ")))
' Displays 10/04/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("de-DE")))
' Displays 10.04.2008                       

Torna alla tabella

Identificatore di formato data lunga ("D")

L'identificatore di formato standard "D" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà corrente DateTimeFormatInfo.LongDatePattern . Ad esempio, la stringa di formato personalizzata per le impostazioni cultura invarianti è "dddd, gg MMMM aaaaa".

Nella tabella seguente sono elencate le proprietà dell'oggetto DateTimeFormatInfo che controllano la formattazione della stringa restituita.

Proprietà Description
LongDatePattern Definisce il formato complessivo della stringa di risultato.
DayNames Definisce i nomi dei giorni localizzati che possono essere visualizzati nella stringa di risultato.
MonthNames Definisce i nomi dei mesi localizzati che possono essere visualizzati nella stringa di risultato.

Nell'esempio seguente viene usato l'identificatore di formato "D" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10);
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("pt-BR")));
// Displays quinta-feira, 10 de abril de 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays jueves, 10 de abril de 2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("pt-BR")))
' Displays quinta-feira, 10 de abril de 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("es-MX")))
' Displays jueves, 10 de abril de 2008                        

Torna alla tabella

Formati di data e ora

Questo gruppo include i formati seguenti:

Identificatore di formato full date short time ("f")

L'identificatore di formato standard "f" rappresenta una combinazione dei modelli di data estesa ("D") e ora breve ("t"), separati da uno spazio.

La stringa di risultato è influenzata dalle informazioni di formattazione di un oggetto specifico DateTimeFormatInfo . Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che possono controllare la formattazione della stringa restituita. L'identificatore di formato personalizzato restituito dalle DateTimeFormatInfo.LongDatePattern proprietà e DateTimeFormatInfo.ShortTimePattern di alcune impostazioni cultura potrebbe non usare tutte le proprietà.

Proprietà Description
LongDatePattern Definisce il formato del componente data della stringa di risultato.
ShortTimePattern Definisce il formato del componente time della stringa di risultato.
DayNames Definisce i nomi dei giorni localizzati che possono essere visualizzati nella stringa di risultato.
MonthNames Definisce i nomi dei mesi localizzati che possono essere visualizzati nella stringa di risultato.
TimeSeparator Definisce la stringa che separa i componenti hour, minute e second di un'ora.
AMDesignator Definisce la stringa che indica le ore da mezzanotte a mezzogiorno in un orologio di 12 ore.
PMDesignator Definisce la stringa che indica le ore da mezzogiorno a prima di mezzanotte in un orologio di 12 ore.

Nell'esempio seguente viene usato l'identificatore di formato "f" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30 AM
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30 AM                        
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30                       

Torna alla tabella

Identificatore di formato full date long time ("F")

L'identificatore di formato standard "F" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà corrente DateTimeFormatInfo.FullDateTimePattern . Ad esempio, la stringa di formato personalizzata per le impostazioni cultura invarianti è "dddd, gg MMMM aa HH:mm:ss".

Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che possono controllare la formattazione della stringa restituita. L'identificatore di formato personalizzato restituito dalla FullDateTimePattern proprietà di alcune impostazioni cultura potrebbe non utilizzare tutte le proprietà.

Proprietà Description
FullDateTimePattern Definisce il formato complessivo della stringa di risultato.
DayNames Definisce i nomi dei giorni localizzati che possono essere visualizzati nella stringa di risultato.
MonthNames Definisce i nomi dei mesi localizzati che possono essere visualizzati nella stringa di risultato.
TimeSeparator Definisce la stringa che separa i componenti hour, minute e second di un'ora.
AMDesignator Definisce la stringa che indica le ore da mezzanotte a mezzogiorno in un orologio di 12 ore.
PMDesignator Definisce la stringa che indica le ore da mezzogiorno a prima di mezzanotte in un orologio di 12 ore.

Nell'esempio seguente viene usato l'identificatore di formato "F" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30:00 AM
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30:00                       

Torna alla tabella

Identificatore di formato di data breve ("g") generale

L'identificatore di formato standard "g" rappresenta una combinazione dei modelli di data breve ("d") e ora breve ("t"), separati da uno spazio.

La stringa di risultato è influenzata dalle informazioni di formattazione di un oggetto specifico DateTimeFormatInfo . Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che possono controllare la formattazione della stringa restituita. L'identificatore di formato personalizzato restituito dalle DateTimeFormatInfo.ShortDatePattern proprietà e DateTimeFormatInfo.ShortTimePattern di alcune impostazioni cultura potrebbe non utilizzare tutte le proprietà.

Proprietà Description
ShortDatePattern Definisce il formato del componente data della stringa di risultato.
ShortTimePattern Definisce il formato del componente time della stringa di risultato.
DateSeparator Definisce la stringa che separa i componenti anno, mese e giorno di una data.
TimeSeparator Definisce la stringa che separa i componenti hour, minute e second di un'ora.
AMDesignator Definisce la stringa che indica le ore da mezzanotte a mezzogiorno in un orologio di 12 ore.
PMDesignator Definisce la stringa che indica le ore da mezzogiorno a prima di mezzanotte in un orologio di 12 ore.

Nell'esempio seguente viene usato l'identificatore di formato "g" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("g",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30 AM
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("fr-BE")));
// Displays 10/04/2008 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("g", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30                      
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30 AM                       
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("fr-BE")))
' Displays 10/04/2008 6:30                        

Torna alla tabella

Identificatore di formato di data estesa generale ("G")

L'identificatore di formato standard "G" rappresenta una combinazione dei modelli di data breve ("d") e di durata ("T"), separati da uno spazio.

La stringa di risultato è influenzata dalle informazioni di formattazione di un oggetto specifico DateTimeFormatInfo . Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che possono controllare la formattazione della stringa restituita. L'identificatore di formato personalizzato restituito dalle DateTimeFormatInfo.ShortDatePattern proprietà e DateTimeFormatInfo.LongTimePattern di alcune impostazioni cultura potrebbe non utilizzare tutte le proprietà.

Proprietà Description
ShortDatePattern Definisce il formato del componente data della stringa di risultato.
LongTimePattern Definisce il formato del componente time della stringa di risultato.
DateSeparator Definisce la stringa che separa i componenti anno, mese e giorno di una data.
TimeSeparator Definisce la stringa che separa i componenti hour, minute e second di un'ora.
AMDesignator Definisce la stringa che indica le ore da mezzanotte a mezzogiorno in un orologio di 12 ore.
PMDesignator Definisce la stringa che indica le ore da mezzogiorno a prima di mezzanotte in un orologio di 12 ore.

Nell'esempio seguente viene usato l'identificatore di formato "G" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("G",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30:00 AM
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("nl-BE")));
// Displays 10/04/2008 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("G", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("nl-BE")))
' Displays 10/04/2008 6:30:00                       

Torna alla tabella

Identificatore di formato round trip ("O", "o")

L'identificatore di formato standard "O" o "o" rappresenta una stringa di formato di data e ora personalizzata usando un modello che mantiene le informazioni sul fuso orario e genera una stringa di risultato conforme a ISO 8601. Per DateTime i valori, questo identificatore di formato è progettato per mantenere i valori di data e ora insieme alla DateTime.Kind proprietà nel testo. La stringa formattata può essere analizzata usando il DateTime.Parse(String, IFormatProvider, DateTimeStyles) metodo o DateTime.ParseExact se il styles parametro è impostato su DateTimeStyles.RoundtripKind.

Per DateOnly i valori, questo identificatore di formato produce una stringa ISO 8601 solo data nel formato "aa-MM-gg". Per TimeOnly i valori, produce una stringa ISO 8601 di sola ora nel formato "HH:mm:ss.fffffff".

L'identificatore di formato standard "O" o "o" corrisponde all'identificatore di formato "aaaa'-'MM'-'dd'T'HH':'mm':'ss'. fffffffK" stringa di formato personalizzata per DateTime i valori e per "aaaa'-'MM'-'dd'T'HH':'mm':'ss'. fffffffzzz" stringa di formato personalizzata per DateTimeOffset i valori. In questa stringa, le coppie di virgolette singole che delimitano singoli caratteri, ad esempio i trattini, i due punti e la lettera "T", indicano che il singolo carattere è un valore letterale che non può essere modificato. Gli apostrofi non vengono visualizzati nella stringa di output.

Identificatore di formato standard "O" o "o" (e "aaaa'-'MM'-'dd'T'HH':'mm':'ss'. fffffffK" stringa di formato personalizzata) sfrutta i tre modi in cui ISO 8601 rappresenta le informazioni sul fuso orario per mantenere la Kind proprietà dei DateTime valori:

  • Il componente del fuso orario dei valori di DateTimeKind.Local data e ora è un offset rispetto all'ora UTC ( ad esempio + 01:00, -07:00). Tutti i DateTimeOffset valori sono rappresentati anche in questo formato.

  • Il componente del fuso orario dei valori di DateTimeKind.Utc data e ora usa "Z" (che indica l'offset zero) per rappresentare l'ora UTC.

  • DateTimeKind.Unspecified i valori di data e ora non dispongono di informazioni sul fuso orario.

Poiché l'identificatore di formato standard "O" o "o" è conforme a uno standard internazionale, l'operazione di formattazione o analisi che usa l'identificatore usa sempre le impostazioni cultura invarianti e il calendario gregoriano.

Le stringhe passate ai Parsemetodi , TryParse, ParseExacte TryParseExact di , DateTimeDateTimeOffset, e DateOnly possono essere analizzate usando l'identificatore di TimeOnlyformato "O" o "o" se si trovano in uno di questi formati. Nel caso di oggetti, l'overload di DateTime analisi chiamato deve includere anche un styles parametro con un valore .DateTimeStyles.RoundtripKind Si noti che se si chiama un metodo di analisi con la stringa di formato personalizzata che corrisponde all'identificatore di formato "O" o "o", non si otterranno gli stessi risultati di "O" o "o". Ciò è dovuto al fatto che i metodi di analisi che usano una stringa di formato personalizzata non possono analizzare la rappresentazione di stringa dei valori di data e ora che non dispongono di un componente del fuso orario o usano "Z" per indicare l'ora UTC.

L'esempio seguente usa l'identificatore di formato "o" per visualizzare una serie di DateTime valori e un DateTimeOffset valore in un sistema nel fuso orario pacifico degli Stati Uniti.

using System;

public class Example
{
   public static void Main()
   {
       DateTime dat = new DateTime(2009, 6, 15, 13, 45, 30,
                                   DateTimeKind.Unspecified);
       Console.WriteLine($"{dat} ({dat.Kind}) --> {dat:O}");

       DateTime uDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Utc);
       Console.WriteLine($"{uDat} ({uDat.Kind}) --> {uDat:O}");

       DateTime lDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Local);
       Console.WriteLine($"{lDat} ({lDat.Kind}) --> {lDat:O}\n");

       DateTimeOffset dto = new DateTimeOffset(lDat);
       Console.WriteLine($"{dto} --> {dto:O}");
   }
}
// The example displays the following output:
//    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
//    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
//    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
//
//    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00
Module Example
    Public Sub Main()
        Dim dat As New Date(2009, 6, 15, 13, 45, 30,
                            DateTimeKind.Unspecified)
        Console.WriteLine("{0} ({1}) --> {0:O}", dat, dat.Kind)

        Dim uDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Utc)
        Console.WriteLine("{0} ({1}) --> {0:O}", uDat, uDat.Kind)

        Dim lDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Local)
        Console.WriteLine("{0} ({1}) --> {0:O}", lDat, lDat.Kind)
        Console.WriteLine()

        Dim dto As New DateTimeOffset(lDat)
        Console.WriteLine("{0} --> {0:O}", dto)
    End Sub
End Module
' The example displays the following output:
'    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
'    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
'    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
'    
'    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00

Nell'esempio seguente viene utilizzato l'identificatore di formato "o" per creare una stringa formattata e quindi viene ripristinato il valore di data e ora originale chiamando un metodo di data e ora Parse .

// Round-trip DateTime values.
DateTime originalDate, newDate;
string dateString;
// Round-trip a local time.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 10, 6, 30, 0), DateTimeKind.Local);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine($"Round-tripped {originalDate} {originalDate.Kind} to {newDate} {newDate.Kind}.");
// Round-trip a UTC time.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 12, 9, 30, 0), DateTimeKind.Utc);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine($"Round-tripped {originalDate} {originalDate.Kind} to {newDate} {newDate.Kind}.");
// Round-trip time in an unspecified time zone.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 13, 12, 30, 0), DateTimeKind.Unspecified);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine($"Round-tripped {originalDate} {originalDate.Kind} to {newDate} {newDate.Kind}.");

// Round-trip a DateTimeOffset value.
DateTimeOffset originalDTO = new DateTimeOffset(2008, 4, 12, 9, 30, 0, new TimeSpan(-8, 0, 0));
dateString = originalDTO.ToString("o");
DateTimeOffset newDTO = DateTimeOffset.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine($"Round-tripped {originalDTO} to {newDTO}.");
// The example displays the following output:
//    Round-tripped 4/10/2008 6:30:00 AM Local to 4/10/2008 6:30:00 AM Local.
//    Round-tripped 4/12/2008 9:30:00 AM Utc to 4/12/2008 9:30:00 AM Utc.
//    Round-tripped 4/13/2008 12:30:00 PM Unspecified to 4/13/2008 12:30:00 PM Unspecified.
//    Round-tripped 4/12/2008 9:30:00 AM -08:00 to 4/12/2008 9:30:00 AM -08:00.
' Round-trip DateTime values.
Dim originalDate, newDate As Date
Dim dateString As String
' Round-trip a local time.
originalDate = Date.SpecifyKind(#4/10/2008 6:30AM#, DateTimeKind.Local)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip a UTC time.
originalDate = Date.SpecifyKind(#4/12/2008 9:30AM#, DateTimeKind.Utc)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip time in an unspecified time zone.
originalDate = Date.SpecifyKind(#4/13/2008 12:30PM#, DateTimeKind.Unspecified)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)

' Round-trip a DateTimeOffset value.
Dim originalDTO As New DateTimeOffset(#4/12/2008 9:30AM#, New TimeSpan(-8, 0, 0))
dateString = originalDTO.ToString("o")
Dim newDTO As DateTimeOffset = DateTimeOffset.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} to {1}.", originalDTO, newDTO)
' The example displays the following output:
'    Round-tripped 4/10/2008 6:30:00 AM Local to 4/10/2008 6:30:00 AM Local.
'    Round-tripped 4/12/2008 9:30:00 AM Utc to 4/12/2008 9:30:00 AM Utc.
'    Round-tripped 4/13/2008 12:30:00 PM Unspecified to 4/13/2008 12:30:00 PM Unspecified.
'    Round-tripped 4/12/2008 9:30:00 AM -08:00 to 4/12/2008 9:30:00 AM -08:00.

Torna alla tabella

Identificatore di formato RFC1123 ("R", "r")

L'identificatore di formato standard "R" o "r" rappresenta una stringa di formato di data e ora personalizzata definita dalla DateTimeFormatInfo.RFC1123Pattern proprietà . Il modello riflette uno standard definito e la proprietà è di sola lettura. Pertanto, è sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato fornito. La stringa di formato personalizzata è "ddd, gg MMM aaaa HH':'mm':'ss 'GMT'". Quando viene usato questo identificatore di formato standard, l'operazione di formattazione o analisi usa sempre le impostazioni cultura invarianti.

La stringa di risultato è influenzata dalle proprietà seguenti dell'oggetto DateTimeFormatInfo restituito dalla DateTimeFormatInfo.InvariantInfo proprietà che rappresenta le impostazioni cultura invarianti.

Proprietà Description
RFC1123Pattern Definisce il formato della stringa di risultato.
AbbreviatedDayNames Definisce i nomi abbreviati dei giorni che possono essere visualizzati nella stringa di risultato.
AbbreviatedMonthNames Definisce i nomi dei mesi abbreviati che possono essere visualizzati nella stringa di risultato.

Anche se lo standard RFC 1123 esprime un'ora come UTC (Coordinated Universal Time), l'operazione di formattazione non modifica il valore dell'oggetto DateTime formattato. Pertanto, è necessario convertire il DateTime valore in UTC chiamando il DateTime.ToUniversalTime metodo prima di eseguire l'operazione di formattazione. Al contrario, DateTimeOffset i valori eseguono automaticamente questa conversione. Non è necessario chiamare il DateTimeOffset.ToUniversalTime metodo prima dell'operazione di formattazione.

Nell'esempio seguente viene usato l'identificatore di formato "r" per visualizzare un DateTime valore e un DateTimeOffset valore in un sistema nel fuso orario pacifico degli Stati Uniti.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
DateTimeOffset dateOffset = new DateTimeOffset(date1,
                            TimeZoneInfo.Local.GetUtcOffset(date1));
Console.WriteLine(date1.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Console.WriteLine(dateOffset.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Dim date1 As Date = #4/10/2008 6:30AM#
Dim dateOffset As New DateTimeOffset(date1, TimeZoneInfo.Local.GetUtcOFfset(date1))
Console.WriteLine(date1.ToUniversalTime.ToString("r"))
' Displays Thu, 10 Apr 2008 13:30:00 GMT                       
Console.WriteLine(dateOffset.ToUniversalTime.ToString("r"))
' Displays Thu, 10 Apr 2008 13:30:00 GMT                        

Torna alla tabella

Identificatore di formato ordinabile ("s")

L'identificatore di formato standard "s" rappresenta una stringa di formato di data e ora personalizzata definita dalla DateTimeFormatInfo.SortableDateTimePattern proprietà . Il modello riflette uno standard definito (ISO 8601) e la proprietà è di sola lettura. Pertanto, è sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato fornito. La stringa di formato personalizzata è "aaaa'-'MM'-'dd'T'HH':'mm':'ss".

Lo scopo dell'identificatore di formato "s" è produrre stringhe di risultato che ordinano in modo coerente in ordine crescente o decrescente in base ai valori di data e ora. Di conseguenza, anche se l'identificatore di formato standard "s" rappresenta un valore di data e ora in un formato coerente, l'operazione di formattazione non modifica il valore dell'oggetto data e ora formattato per riflettere la relativa DateTime.Kind proprietà o il relativo DateTimeOffset.Offset valore. Ad esempio, le stringhe di risultato prodotte formattando i valori di data e ora 2014-11-15T18:32:17+00:00 e 2014-11-15T18:32:17+08:00 sono identici.

Quando viene usato questo identificatore di formato standard, l'operazione di formattazione o analisi usa sempre le impostazioni cultura invarianti.

Nell'esempio seguente viene usato l'identificatore di formato "s" per visualizzare un DateTime valore e un DateTimeOffset valore in un sistema nel fuso orario pacifico degli Stati Uniti.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("s"));
// Displays 2008-04-10T06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("s"))
' Displays 2008-04-10T06:30:00                       

Torna alla tabella

Identificatore di formato ordinabile universale ("u")

L'identificatore di formato standard "u" rappresenta una stringa di formato di data e ora personalizzata definita dalla DateTimeFormatInfo.UniversalSortableDateTimePattern proprietà . Il modello riflette uno standard definito e la proprietà è di sola lettura. Pertanto, è sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato fornito. La stringa di formato personalizzata è "aaaa'-'MM'-'dd HH':'mm':'ss'Z'". Quando viene usato questo identificatore di formato standard, l'operazione di formattazione o analisi usa sempre le impostazioni cultura invarianti.

Anche se la stringa di risultato deve esprimere un'ora come UTC (Coordinated Universal Time), non viene eseguita alcuna conversione del valore originale DateTime durante l'operazione di formattazione. Pertanto, è necessario convertire un DateTime valore in UTC chiamando il DateTime.ToUniversalTime metodo prima di formattarlo. Al contrario, DateTimeOffset i valori eseguono automaticamente questa conversione. Non è necessario chiamare il DateTimeOffset.ToUniversalTime metodo prima dell'operazione di formattazione.

Nell'esempio seguente viene usato l'identificatore di formato "u" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToUniversalTime().ToString("u"));
// Displays 2008-04-10 13:30:00Z
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToUniversalTime.ToString("u"))
' Displays 2008-04-10 13:30:00Z                       

Torna alla tabella

Identificatore di formato completo universale ("U")

L'identificatore di formato standard "U" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà delle DateTimeFormatInfo.FullDateTimePattern impostazioni cultura specificate. Il modello è lo stesso del modello "F". Tuttavia, il DateTime valore viene convertito automaticamente in formato UTC prima che venga formattato.

Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che possono controllare la formattazione della stringa restituita. L'identificatore di formato personalizzato restituito dalla FullDateTimePattern proprietà di alcune impostazioni cultura potrebbe non utilizzare tutte le proprietà.

Proprietà Description
FullDateTimePattern Definisce il formato complessivo della stringa di risultato.
DayNames Definisce i nomi dei giorni localizzati che possono essere visualizzati nella stringa di risultato.
MonthNames Definisce i nomi dei mesi localizzati che possono essere visualizzati nella stringa di risultato.
TimeSeparator Definisce la stringa che separa i componenti hour, minute e second di un'ora.
AMDesignator Definisce la stringa che indica le ore da mezzanotte a mezzogiorno in un orologio di 12 ore.
PMDesignator Definisce la stringa che indica le ore da mezzogiorno a prima di mezzanotte in un orologio di 12 ore.

L'identificatore di formato "U" non è supportato dal DateTimeOffset tipo e genera un'eccezione FormatException se viene usata per formattare un DateTimeOffset valore.

Nell'esempio seguente viene usato l'identificatore di formato "U" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("U",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 1:30:00 PM
Console.WriteLine(date1.ToString("U",
                  CultureInfo.CreateSpecificCulture("sv-FI")));
// Displays den 10 april 2008 13:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("U", CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 1:30:00 PM                       
Console.WriteLine(date1.ToString("U", CultureInfo.CreateSpecificCulture("sv-FI")))
' Displays den 10 april 2008 13:30:00                       

Torna alla tabella

Formati ora

Questo gruppo include i formati seguenti:

Identificatore di formato breve ("t")

L'identificatore di formato standard "t" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà corrente DateTimeFormatInfo.ShortTimePattern . Ad esempio, la stringa di formato personalizzata per le impostazioni cultura invarianti è "HH:mm".

La stringa di risultato è influenzata dalle informazioni di formattazione di un oggetto specifico DateTimeFormatInfo . Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che possono controllare la formattazione della stringa restituita. L'identificatore di formato personalizzato restituito dalla DateTimeFormatInfo.ShortTimePattern proprietà di alcune impostazioni cultura potrebbe non utilizzare tutte le proprietà.

Proprietà Description
ShortTimePattern Definisce il formato del componente time della stringa di risultato.
TimeSeparator Definisce la stringa che separa i componenti hour, minute e second di un'ora.
AMDesignator Definisce la stringa che indica le ore da mezzanotte a mezzogiorno in un orologio di 12 ore.
PMDesignator Definisce la stringa che indica le ore da mezzogiorno a prima di mezzanotte in un orologio di 12 ore.

Nell'esempio seguente viene usato l'identificatore di formato "t" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30 AM
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30 AM                        
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30                      

Torna alla tabella

Identificatore di formato long time ("T")

L'identificatore di formato standard "T" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà delle DateTimeFormatInfo.LongTimePattern impostazioni cultura specifiche. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura invarianti è "HH:mm:ss".

Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che possono controllare la formattazione della stringa restituita. L'identificatore di formato personalizzato restituito dalla DateTimeFormatInfo.LongTimePattern proprietà di alcune impostazioni cultura potrebbe non utilizzare tutte le proprietà.

Proprietà Description
LongTimePattern Definisce il formato del componente time della stringa di risultato.
TimeSeparator Definisce la stringa che separa i componenti hour, minute e second di un'ora.
AMDesignator Definisce la stringa che indica le ore da mezzanotte a mezzogiorno in un orologio di 12 ore.
PMDesignator Definisce la stringa che indica le ore da mezzogiorno a prima di mezzanotte in un orologio di 12 ore.

Nell'esempio seguente viene usato l'identificatore di formato "T" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30:00 AM
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30:00 AM                       
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30:00                      

Torna alla tabella

Formati di data parziale

Questo gruppo include i formati seguenti:

Identificatore di formato month ("M", "m")

L'identificatore di formato standard "M" o "m" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà corrente DateTimeFormatInfo.MonthDayPattern . Ad esempio, la stringa di formato personalizzata per le impostazioni cultura invarianti è "MMMM dd".

Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che controllano la formattazione della stringa restituita.

Proprietà Description
MonthDayPattern Definisce il formato complessivo della stringa di risultato.
MonthNames Definisce i nomi dei mesi localizzati che possono essere visualizzati nella stringa di risultato.

Nell'esempio seguente viene usato l'identificatore di formato "m" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays April 10
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("ms-MY")));
// Displays 10 April
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays April 10                        
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("ms-MY")))
' Displays 10 April                       

Torna alla tabella

Identificatore di formato year month ("Y", "y")

L'identificatore di formato standard "Y" o "y" rappresenta una stringa di formato di data e ora personalizzata definita dalla DateTimeFormatInfo.YearMonthPattern proprietà di impostazioni cultura specificate. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura invarianti è "Aaa MMMM".

Nella tabella seguente sono elencate le DateTimeFormatInfo proprietà dell'oggetto che controllano la formattazione della stringa restituita.

Proprietà Description
YearMonthPattern Definisce il formato complessivo della stringa di risultato.
MonthNames Definisce i nomi dei mesi localizzati che possono essere visualizzati nella stringa di risultato.

Nell'esempio seguente viene usato l'identificatore di formato "y" per visualizzare un valore di data e ora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("Y",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays April, 2008
Console.WriteLine(date1.ToString("y",
                  CultureInfo.CreateSpecificCulture("af-ZA")));
// Displays April 2008
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("Y", CultureInfo.CreateSpecificCulture("en-US")))
' Displays April, 2008                       
Console.WriteLine(date1.ToString("y", CultureInfo.CreateSpecificCulture("af-ZA")))
' Displays April 2008                       

Torna alla tabella

Formattazione DateOnly e TimeOnly

DateOnly i tipi e TimeOnly supportano un subset delle stringhe di formato di data e ora standard:

  • DateOnly supporta gli identificatori di formato correlati alla data:

    • "d" (data breve), "D" (data estesa)
    • "M" o "m" (mese/giorno)
    • "Y" o "y" (anno/mese)
    • "O" o "o" (round trip, solo parte data)
    • "R" o "r" (solo RFC1123, parte di data)
  • TimeOnly supporta gli identificatori di formato correlati al tempo:

    • "t" (breve tempo), "T" (tempo lungo)
    • "O" o "o" (round trip, solo tempo)
    • "R" o "r" (RFC1123, solo tempo)

Gli identificatori di formato che combinano le informazioni di data e ora (ad esempio "f", "F", "g", "G", "s", "u", "U") generano un'eccezione FormatException quando viene usata con DateOnly o TimeOnly.

Impostazioni del Pannello di controllo

In Windows le impostazioni nell'elemento Opzioni internazionali e linguistiche nel Pannello di controllo influenzano la stringa di risultato prodotta da un'operazione di formattazione. Queste impostazioni vengono utilizzate per inizializzare l'oggetto associato alle impostazioni cultura correnti, che fornisce i valori utilizzati per gestire la DateTimeFormatInfo formattazione. I computer che usano impostazioni diverse generano stringhe di risultati diverse.

Inoltre, se si usa il CultureInfo(String) costruttore per creare un'istanza di un nuovo CultureInfo oggetto che rappresenta le stesse impostazioni cultura delle impostazioni cultura di sistema correnti, tutte le personalizzazioni stabilite dall'elemento Opzioni internazionali e linguistiche nel Pannello di controllo verranno applicate al nuovo CultureInfo oggetto. È possibile utilizzare il CultureInfo(String, Boolean) costruttore per creare un CultureInfo oggetto che non riflette le personalizzazioni di un sistema.

Proprietà DateTimeFormatInfo

La formattazione è influenzata dalle proprietà dell'oggetto corrente DateTimeFormatInfo , che viene fornita in modo implicito dalle impostazioni cultura correnti o in modo esplicito dal IFormatProvider parametro del metodo che richiama la formattazione. Per il parametro , l'applicazione IFormatProvider deve specificare un CultureInfo oggetto , che rappresenta impostazioni cultura o un DateTimeFormatInfo oggetto , che rappresenta le convenzioni di formattazione di data e ora di una determinata cultura. Molti degli identificatori di formato di data e ora standard sono alias per i modelli di formattazione definiti dalle proprietà dell'oggetto corrente DateTimeFormatInfo . L'applicazione può modificare il risultato prodotto da alcuni identificatori di formato di data e ora standard modificando i modelli di formato di data e ora corrispondenti della proprietà corrispondente DateTimeFormatInfo .

Vedere anche