Stringhe di formato di data e ora personalizzato

Una stringa di formato di data e ora definisce la rappresentazione di testo di un valore DateTime o DateTimeOffset risultante da un'operazione di formattazione. Può anche definire la rappresentazione di un valore di data e ora richiesto in un'operazione di analisi per convertire correttamente la stringa in una data e ora. Una stringa di formato personalizzata è costituita da uno o più identificatori di formato di data e ora personalizzati. Qualsiasi stringa diversa da una stringa di formato di data e ora standard viene interpretata come stringa di formato di data e ora personalizzato.

Suggerimento

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

Le stringhe di formato data e ora personalizzate possono essere usate sia con valori DateTime sia con valori DateTimeOffset.

Nota

Alcuni degli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.

Il fuso orario locale dello strumento di esecuzione e playground per codice inline Try.NET è Coordinated Universal Time o ora UTC. Ciò può influire sul comportamento e l'output degli esempi che illustrano i tipi DateTime, DateTimeOffset e TimeZoneInfo e i relativi membri.

Nelle operazioni di formattazione, le stringhe di formato di data e ora personalizzato possono essere usate con il ToString metodo di un'istanza di data e ora o con un metodo che supporta la formattazione composita. Nell'esempio seguente vengono illustrati entrambi gli usi.

DateTime thisDate1 = new DateTime(2011, 6, 10);
Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".");

DateTimeOffset thisDate2 = new DateTimeOffset(2011, 6, 10, 15, 24, 16,
                                              TimeSpan.Zero);
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
                   thisDate2);
// The example displays the following output:
//    Today is June 10, 2011.
//    The current date and time: 06/10/11 15:24:16 +00:00
Dim thisDate1 As Date = #6/10/2011#
Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".")

Dim thisDate2 As New DateTimeOffset(2011, 6, 10, 15, 24, 16, TimeSpan.Zero)
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
                  thisDate2)
' The example displays the following output:
'    Today is June 10, 2011.
'    The current date and time: 06/10/11 15:24:16 +00:00

Nelle operazioni di analisi, le stringhe di formato di data e ora personalizzate possono essere usate con i metodi DateTime.ParseExact, DateTime.TryParseExact, DateTimeOffset.ParseExact e DateTimeOffset.TryParseExact. Questi metodi richiedono che una stringa di input sia esattamente conforme a un modello specifico affinché l'operazione di analisi abbia esito positivo. Nell'esempio seguente viene illustrata una chiamata al metodo DateTimeOffset.ParseExact(String, String, IFormatProvider) per analizzare una data che deve includere un giorno, un mese e un anno a due cifre.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateValues = { "30-12-2011", "12-30-2011",
                              "30-12-11", "12-30-11" };
      string pattern = "MM-dd-yy";
      DateTime parsedDate;

      foreach (var dateValue in dateValues) {
         if (DateTime.TryParseExact(dateValue, pattern, null,
                                   DateTimeStyles.None, out parsedDate))
            Console.WriteLine("Converted '{0}' to {1:d}.",
                              dateValue, parsedDate);
         else
            Console.WriteLine("Unable to convert '{0}' to a date and time.",
                              dateValue);
      }
   }
}
// The example displays the following output:
//    Unable to convert '30-12-2011' to a date and time.
//    Unable to convert '12-30-2011' to a date and time.
//    Unable to convert '30-12-11' to a date and time.
//    Converted '12-30-11' to 12/30/2011.
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim dateValues() As String = {"30-12-2011", "12-30-2011",
                                        "30-12-11", "12-30-11"}
        Dim pattern As String = "MM-dd-yy"
        Dim parsedDate As Date

        For Each dateValue As String In dateValues
            If DateTime.TryParseExact(dateValue, pattern, Nothing,
                                      DateTimeStyles.None, parsedDate) Then
                Console.WriteLine("Converted '{0}' to {1:d}.",
                                  dateValue, parsedDate)
            Else
                Console.WriteLine("Unable to convert '{0}' to a date and time.",
                                  dateValue)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Unable to convert '30-12-2011' to a date and time.
'    Unable to convert '12-30-2011' to a date and time.
'    Unable to convert '30-12-11' to a date and time.
'    Converted '12-30-11' to 12/30/2011.

Nella tabella seguente vengono descritti gli identificatori di formato data e ora personalizzati e viene visualizzata una stringa di risultato prodotta da ogni identificatore di formato. Per impostazione predefinita, le stringhe di risultato riflettono le convenzioni di formattazione delle impostazioni cultura en-US. Se un identificatore di formato specifico produce una stringa di risultato localizzata, nell'esempio vengono anche indicate le impostazioni cultura alle quali si applica la stringa di risultato. Per altre informazioni sull'uso di stringhe di formato di data e ora personalizzato, vedere la sezione Note.

Identificatore di formato Descrizione Esempi
"d" Giorno del mese, da 1 a 31.

Altre informazioni: Identificatore di formato personalizzato "d".
2009-06-01T13:45:30 -> 1

2009-06-15T13:45:30 -> 15
"dd" Giorno del mese, da 01 a 31.

Altre informazioni: Identificatore di formato personalizzato "dd".
2009-06-01T13:45:30 -> 01

2009-06-15T13:45:30 -> 15
"ddd" Nome abbreviato del giorno della settimana.

Altre informazioni: Identificatore di formato personalizzato "ddd".
2009-06-15T13:45:30 -> Mon (en-US)

2009-06-15T13:45:30 -> Пн (ru-RU)

2009-06-15T13:45:30 -> lun. (fr-FR)
"dddd" Nome completo del giorno della settimana.

Altre informazioni: Identificatore di formato personalizzato "dddd".
2009-06-15T13:45:30 -> Monday (en-US)

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

2009-06-15T13:45:30 -> lundi (fr-FR)
"f" Decimi di secondo in un valore data e ora.

Altre informazioni: Identificatore di formato personalizzato "f".
2009-06-15T13:45:30.6170000 -> 6

2009-06-15T13:45:30.05 -> 0
"ff" Centesimi di secondo in un valore data e ora.

Altre informazioni: identificatore di formato personalizzato "FF".
2009-06-15T13:45:30.6170000 -> 61

2009-06-15T13:45:30.0050000 -> 00
"fff" Millisecondi in un valore data e ora.

Altre informazioni: Identificatore di formato personalizzato "fff".
6/15/2009 13:45:30.617 -> 617

6/15/2009 13:45:30.0005 -> 000
"ffff" Decimillesimi di secondo in un valore data e ora.

Altre informazioni: identificatore di formato personalizzato "ffff".
2009-06-15T13:45:30.6175000 -> 6175

2009-06-15T13:45:30.0000500 -> 0000
"fffff" Centomillesimi di secondo in un valore data e ora.

Altre informazioni: Identificatore di formato personalizzato "fffff".
2009-06-15T13:45:30.6175400 -> 61754

6/15/2009 13:45:30.000005 -> 00000
"ffffff" Milionesimi di secondo in un valore data e ora.

Ulteriori informazioni: identificatore di formato personalizzato "FFFFFF".
2009-06-15T13:45:30.6175420 -> 617542

2009-06-15T13:45:30.0000005 -> 000000
"fffffff" Decine di milionesimi di secondo in un valore data e ora.

Ulteriori informazioni: identificatore di formato personalizzato "fffffff".
2009-06-15T13:45:30.6175425 -> 6175425

2009-06-15T13:45:30.0001150 -> 0001150
"F" Se diverso da zero, decimi di secondo in un valore data e ora.

Ulteriori informazioni: identificatore di formato personalizzato "F".
2009-06-15T13:45:30.6170000 -> 6

2009-06-15T13:45:30.0500000 -> (nessun output)
"FF" Se diverso da zero, centesimi di secondo in un valore data e ora.

Altre informazioni: Identificatore di formato personalizzato "FF".
2009-06-15T13:45:30.6170000 -> 61

2009-06-15T13:45:30.0050000 -> (nessun output)
"FFF" Se diverso da zero, millisecondi in un valore data e ora.

Altre informazioni: identificatore di formato personalizzato "fff".
2009-06-15T13:45:30.6170000 -> 617

2009-06-15T13:45:30.0005000 -> (nessun output)
"FFFF" Se diverso da zero, decimillesimi di secondo in un valore data e ora.

Altre informazioni: Identificatore di formato personalizzato "FFFF".
2009-06-15T13:45:30.5275000 -> 5275

2009-06-15T13:45:30.0000500 -> (nessun output)
"FFFFF" Se diverso da zero, centomillesimi di secondo in un valore data e ora.

Ulteriori informazioni: identificatore di formato personalizzato "fffff".
2009-06-15T13:45:30.6175400 -> 61754

2009-06-15T13:45:30.0000050 -> (nessun output)
"FFFFFF" Se diverso da zero, milionesimi di secondo in un valore data e ora.

Altre informazioni: Identificatore di formato personalizzato "FFFFFF".
2009-06-15T13:45:30.6175420 -> 617542

2009-06-15T13:45:30.0000005 -> (nessun output)
"FFFFFFF" Se diverso da zero, decimilionesimi di secondo in un valore data e ora.

Altre informazioni: Identificatore di formato personalizzato "FFFFFFF".
2009-06-15T13:45:30.6175425 -> 6175425

2009-06-15T13:45:30.0001150 -> 000115
"g", "gg" Periodo o era.

Altre informazioni: Identificatore di formato personalizzato "g" o "gg".
2009-06-15T13:45:30.6170000 -> A.D.
"h" Ora, usando un orario in formato 12 ore da 1 a 12.

Altre informazioni: identificatore di formato personalizzato "h".
2009-06-15T01:45:30 -> 1

2009-06-15T13:45:30 -> 1
"hh" Ora, usando un orario in formato 12 ore da 01 a 12.

Ulteriori informazioni: identificatore di formato personalizzato "HH".
2009-06-15T01:45:30 -> 01

2009-06-15T13:45:30 -> 01
"H" Ora, usando un orario in formato 24 ore da 0 a 23.

Altre informazioni: Identificatore di formato personalizzato "H".
2009-06-15T01:45:30 -> 1

2009-06-15T13:45:30 -> 13
"HH" Ora, usando un orario in formato 24 ore da 00 a 23.

Altre informazioni: Identificatore di formato personalizzato "HH".
2009-06-15T01:45:30 -> 01

2009-06-15T13:45:30 -> 13
"K" Informazioni sul fuso orario.

Altre informazioni: Identificatore di formato personalizzato "K".
Con valori DateTime:

2009-06-15T13:45:30, tipo non specificato ->

2009-06-15T13:45:30, tipo UTC -> Z

2009-06-15T13:45:30, tipo locale -> -07:00 (dipende dalle impostazioni del computer locale)

Con valori DateTimeOffset:

2009-06-15T01:45:30-07:00 --> -07:00

2009-06-15T08:45:30+00:00 --> +00:00
"m" Minuti, da 0 a 59.

Altre informazioni: identificatore di formato personalizzato "m".
2009-06-15T01:09:30 -> 9

2009-06-15T13:29:30 -> 29
"mm" Minuti, da 00 a 59.

Altre informazioni: Identificatore di formato personalizzato "mm".
2009-06-15T01:09:30 -> 09

2009-06-15T01:45:30 -> 45
"M" Mese, da 1 a 12.

Altre informazioni: Identificatore di formato personalizzato "M".
2009-06-15T13:45:30 -> 6
"MM" Mese, da 01 a 12.

Altre informazioni: identificatore di formato personalizzato "mm".
2009-06-15T13:45:30 -> 06
"MMM" Nome abbreviato del mese.

Altre informazioni: Identificatore di formato personalizzato "MMM".
2009-06-15T13:45:30 -> Jun (en-US)

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

2009-06-15T13:45:30 -> Jun (zu-ZA)
"MMMM" Nome completo del mese.

Altre informazioni: Identificatore di formato personalizzato "MMMM".
2009-06-15T13:45:30 -> June (en-US)

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

2009-06-15T13:45:30 -> uJuni (zu-ZA)
"s" Secondi, da 0 a 59.

Altre informazioni: Identificatore di formato personalizzato "s".
2009-06-15T13:45:09 -> 9
"ss" Secondi, da 00 a 59.

Altre informazioni: Identificatore di formato personalizzato "ss".
2009-06-15T13:45:09 -> 09
"t" Primo carattere dell'indicatore AM/PM.

Altre informazioni: Identificatore di formato personalizzato "t".
2009-06-15T13:45:30 -> P (en-US)

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

2009-06-15T13:45:30 -> (fr-FR)
"tt" Indicatore AM/PM.

Altre informazioni: Identificatore di formato personalizzato "tt".
2009-06-15T13:45:30 -> PM (en-US)

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

2009-06-15T13:45:30 -> (fr-FR)
"y" Anno, da 0 a 99.

Altre informazioni: Identificatore di formato personalizzato "y".
0001-01-01T00:00:00 -> 1

0900-01-01T00:00:00 -> 0

1900-01-01T00:00:00 -> 0

2009-06-15T13:45:30 -> 9

2019-06-15T13:45:30 -> 19
"yy" Anno, da 00 a 99.

Altre informazioni: Identificatore di formato personalizzato "yy".
0001-01-01T00:00:00 -> 01

0900-01-01T00:00:00 -> 00

1900-01-01T00:00:00 -> 00

2019-06-15T13:45:30 -> 19
"yyy" Anno, con un minimo di tre cifre.

Altre informazioni: Identificatore di formato personalizzato "yyy".
0001-01-01T00:00:00 -> 001

0900-01-01T00:00:00 -> 900

1900-01-01T00:00:00 -> 1900

2009-06-15T13:45:30 -> 2009
"yyyy" Anno, come numero a quattro cifre.

Altre informazioni: Identificatore di formato personalizzato "yyyy".
0001-01-01T00:00:00 -> 0001

0900-01-01T00:00:00 -> 0900

1900-01-01T00:00:00 -> 1900

2009-06-15T13:45:30 -> 2009
"yyyyy" Anno, come numero a cinque cifre.

Altre informazioni: Identificatore di formato personalizzato "yyyyy".
0001-01-01T00:00:00 -> 00001

2009-06-15T13:45:30 -> 02009
"z" Offset delle ore rispetto a UTC, senza zeri iniziali.

Altre informazioni: Identificatore di formato personalizzato "z".
2009-06-15T13:45:30-07:00 -> -7
"zz" Offset delle ore rispetto a UTC, con uno zero iniziale per un valore a una sola cifra.

Altre informazioni: Identificatore di formato personalizzato "zz".
2009-06-15T13:45:30-07:00 -> -07
"zzz" Offset di ore e minuti rispetto a UTC.

Altre informazioni: Identificatore di formato personalizzato "zzz".
2009-06-15T13:45:30-07:00 -> -07:00
":" Separatore dell'ora.

Altre informazioni: Identificatore di formato personalizzato ":".
2009-06-15T13:45:30 -> : (en-US)

2009-06-15T13:45:30 -> . (it-IT)

2009-06-15T13:45:30 -> : (ja-JP)
"/" Separatore di data.

Ulteriori informazioni: identificatore di formato personalizzato "/".
2009-06-15T13:45:30 -> / (en-US)

2009-06-15T13:45:30 -> - (ar-DZ)

2009-06-15T13:45:30 -> . (tr-TR)
"stringa"

'String'
Delimitatore di stringa letterale.

Altre informazioni: caratteri letterali.
2009-06-15T13:45:30 ("arr:" h:m t) -> arr: 1:45 P

2009-06-15T13:45:30 ('arr:' h:m t) -> arr: 1:45 P
% Definisce il carattere seguente come identificatore di formato personalizzato.

Altre informazioni: Uso di singoli identificatori di formato personalizzati.
2009-06-15T13:45:30 (%h) -> 1
\ Carattere di escape.

Altre informazioni: caratteri letterali e Uso del carattere di Escape.
2009-06-15T13:45:30 (h \h) -> 1 h
Qualsiasi altro carattere Il carattere viene copiato nella stringa di risultato senza alcuna modifica.

Altre informazioni: caratteri letterali.
2009-06-15T01:45:30 (arr hh:mm t) -> arr 01:45 A

Nelle sezioni seguenti vengono fornite altre informazioni su ogni identificatore di formato data e ora personalizzato. Se non specificato diversamente, ogni identificatore genera una rappresentazione stringa identica, indipendentemente dal fatto che venga usato con un valore DateTime o DateTimeOffset.

Identificatore di formato "d" del giorno

Identificatore di formato personalizzato "d"

L'identificatore di formato personalizzato "d" rappresenta il giorno del mese come numero compreso tra 1 e 31. Un giorno a una sola cifra viene formattato senza uno zero iniziale.

Se l'identificatore di formato "d" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "d". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "d" in diverse stringhe di formato.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("d, M",
                  CultureInfo.InvariantCulture));
// Displays 29, 8

Console.WriteLine(date1.ToString("d MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays 29 August
Console.WriteLine(date1.ToString("d MMMM",
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("d, M", _
                  CultureInfo.InvariantCulture))
' Displays 29, 8

Console.WriteLine(date1.ToString("d MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays 29 August
Console.WriteLine(date1.ToString("d MMMM", _
                  CultureInfo.CreateSpecificCulture("es-MX")))
' Displays 29 agosto                                                

Torna alla tabella

Identificatore di formato personalizzato "dd"

La stringa di formato personalizzata "dd" rappresenta il giorno del mese come numero compreso tra 01 e 31. Un giorno a una sola cifra viene formattato con uno zero iniziale.

L'esempio seguente include l'identificatore di formato personalizzato "dd" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM",
                  CultureInfo.InvariantCulture));
// 02, 01
Dim date1 As Date = #1/2/2008 6:30:15AM#

Console.WriteLine(date1.ToString("dd, MM", _
                  CultureInfo.InvariantCulture))
' 02, 01

Torna alla tabella

Identificatore di formato personalizzato "ddd"

L'identificatore di formato personalizzato "ddd" rappresenta il nome abbreviato del giorno della settimana. Il nome abbreviato localizzato del giorno della settimana viene recuperato dalla proprietà DateTimeFormatInfo.AbbreviatedDayNames delle impostazioni cultura correnti o specificate.

L'esempio seguente include l'identificatore di formato personalizzato "ddd" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays ven. 29 août                                                

Torna alla tabella

Identificatore di formato personalizzato "dddd"

L'identificatore di formato personalizzato "dddd" (più qualsiasi numero di identificatori "d" aggiuntivi) rappresenta il nome completo del giorno della settimana. Il nome localizzato del giorno della settimana viene recuperato dalla proprietà DateTimeFormatInfo.DayNames delle impostazioni cultura correnti o specificate.

L'esempio seguente include l'identificatore di formato personalizzato "dddd" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("it-IT")))
' Displays venerdì 29 agosto                                          

Torna alla tabella

Identificatore frazione "f" secondi minuscoli

Identificatore di formato personalizzato "f"

L'identificatore di formato personalizzato "f" rappresenta la cifra più significativa della frazione di secondi, ovvero i decimi di secondo in un valore di data e ora.

Se l'identificatore di formato "f" viene usato senza altri identificatori di formato, viene interpretato come l'identificatore di formato di data e ora standard "f". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

Quando si usano identificatori di formato "f" come parte di una stringa di formato fornita al metodo ParseExact, TryParseExact, ParseExact o TryParseExact, il numero di identificatori di formato "f" indica il numero di cifre più significative della frazione di secondi che deve essere presente per analizzare correttamente la stringa.

L'esempio seguente include l'identificatore di formato personalizzato "f" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Torna alla tabella

Identificatore di formato personalizzato "FF"

L'identificatore di formato personalizzato "ff" rappresenta le due cifre più significative della frazione di secondi, ovvero i centesimi di secondo in un valore di data e ora.

L'esempio seguente include l'identificatore di formato personalizzato "ff" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Torna alla tabella

Identificatore di formato personalizzato "fff"

L'identificatore di formato personalizzato "fff" rappresenta le tre cifre più significative della frazione di secondi, ovvero i millisecondi in un valore di data e ora.

L'esempio seguente include l'identificatore di formato personalizzato "fff" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Torna alla tabella

Identificatore di formato personalizzato "ffff"

L'identificatore di formato personalizzato "ffff" rappresenta le quattro cifre più significative della frazione di secondi, ovvero i decimillesimi di secondo in un valore di data e ora.

Sebbene sia possibile visualizzare i decimillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT versione 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore di formato personalizzato "fffff"

L'identificatore di formato personalizzato "fffff" rappresenta le cinque cifre più significative della frazione di secondi, ovvero i centomillesimi di secondo in un valore di data e ora.

Sebbene sia possibile visualizzare i centomillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore di formato personalizzato "FFFFFF"

L'identificatore di formato personalizzato "ffffff" rappresenta le sei cifre più significative della frazione di secondi, ovvero i milionesimi di secondo in un valore di data e ora.

Sebbene sia possibile visualizzare i milionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore di formato personalizzato "fffffff"

L'identificatore di formato personalizzato "fffffff" rappresenta le sette cifre più significative della frazione di secondi, ovvero i decimilionesimi di secondo in un valore di data e ora.

Sebbene sia possibile visualizzare i decimilionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore della frazione di secondi "F" maiuscoli

Identificatore di formato personalizzato "F"

L'identificatore di formato personalizzato "F" rappresenta la cifra più significativa della frazione di secondi, ovvero i decimi di secondo in un valore di data e ora. Se la cifra è zero, non viene visualizzato nulla e non viene visualizzato anche il separatore decimale che segue il numero di secondi.

Se l'identificatore di formato "F" viene usato senza altri identificatori di formato, viene interpretato come l'identificatore di formato di data e ora standard "F". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

Il numero di identificatoti di formato "F" usati con il metodo ParseExact, TryParseExact, ParseExact o TryParseExact indica il numero massimo di cifre più significative della frazione di secondi che possono essere presenti per analizzare correttamente la stringa.

L'esempio seguente include l'identificatore di formato personalizzato "F" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Torna alla tabella

Identificatore di formato personalizzato "FF"

L'identificatore di formato personalizzato "FF" rappresenta le due cifre più significative della frazione di secondi, ovvero i centesimi di secondo in un valore di data e ora. Gli zeri finali non vengono visualizzati. Non viene visualizzato nulla se le due cifre significative sono pari a zero e in questo caso non viene visualizzato anche il separatore decimale che segue il numero di secondi.

L'esempio seguente include l'identificatore di formato personalizzato "FF" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Torna alla tabella

Identificatore di formato personalizzato "FFF"

L'identificatore di formato personalizzato "FFF" rappresenta le tre cifre più significative della frazione di secondi, ovvero i millisecondi in un valore di data e ora. Gli zeri finali non vengono visualizzati. Non viene visualizzato nulla se le tre cifre significative sono pari a zero e in questo caso non viene visualizzato anche il separatore decimale che segue il numero di secondi.

L'esempio seguente include l'identificatore di formato personalizzato "FFF" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Torna alla tabella

Identificatore di formato personalizzato "FFFF"

L'identificatore di formato personalizzato "FFFF" rappresenta le quattro cifre più significative della frazione di secondi, ovvero i decimillesimi di secondo in un valore di data e ora. Gli zeri finali non vengono visualizzati. Non viene visualizzato nulla se le quattro cifre significative sono pari a zero e in questo caso non viene visualizzato anche il separatore decimale che segue il numero di secondi.

Sebbene sia possibile visualizzare i decimillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore di formato personalizzato "FFFFF"

L'identificatore di formato personalizzato "FFFFF" rappresenta le cinque cifre più significative della frazione di secondi, ovvero i centomillesimi di secondo in un valore di data e ora. Gli zeri finali non vengono visualizzati. Non viene visualizzato nulla se le cinque cifre significative sono pari a zero e in questo caso non viene visualizzato anche il separatore decimale che segue il numero di secondi.

Sebbene sia possibile visualizzare i centomillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore di formato personalizzato "FFFFFF"

L'identificatore di formato personalizzato "FFFFFF" rappresenta le sei cifre più significative della frazione di secondi, ovvero i milionesimi di secondo in un valore di data e ora. Gli zeri finali non vengono visualizzati. Non viene visualizzato nulla se le sei cifre significative sono pari a zero e in questo caso non viene visualizzato anche il separatore decimale che segue il numero di secondi.

Sebbene sia possibile visualizzare i milionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore di formato personalizzato "FFFFFFF"

L'identificatore di formato personalizzato "FFFFFFF" rappresenta le sette cifre più significative della frazione di secondi, ovvero i decimilionesimi di secondo in un valore di data e ora. Gli zeri finali non vengono visualizzati. Non viene visualizzato nulla se le sette cifre significative sono pari a zero e in questo caso non viene visualizzato anche il separatore decimale che segue il numero di secondi.

Sebbene sia possibile visualizzare i decimilionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.

Torna alla tabella

Identificatore di formato "g" era

Identificatore di formato personalizzato "g" o "gg"

Gli identificatori di formato personalizzati "g" o "gg" (più qualsiasi numero di identificatori "g" aggiuntivi) rappresentano il periodo o l'era, ad esempio D.C. Questo identificatore viene ignorato dall'operazione di formattazione se la data da formattare non è associata a una stringa di periodo o di era.

Se l'identificatore di formato "g" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "g". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "g" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(70, 08, 04);

Console.WriteLine(date1.ToString("MM/dd/yyyy g",
                  CultureInfo.InvariantCulture));
// Displays 08/04/0070 A.D.
Console.WriteLine(date1.ToString("MM/dd/yyyy g",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 08/04/0070 ap. J.-C.
Dim date1 As Date = #08/04/0070#

Console.WriteLine(date1.ToString("MM/dd/yyyy g", _
                  CultureInfo.InvariantCulture))
' Displays 08/04/0070 A.D.                        
Console.WriteLine(date1.ToString("MM/dd/yyyy g", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 08/04/0070 ap. J.-C.

Torna alla tabella

Identificatore di formato "h" nell'ora minuscola

Identificatore di formato personalizzato "h"

L'identificatore di formato personalizzato "h" rappresenta l'ora come numero compreso tra 1 e 12, ovvero l'ora rappresentata nell'orario in formato 12 ore in base al quale il conteggio riparte da mezzanotte o da mezzogiorno. Una particolare ora dopo mezzanotte non è distinguibile dalla stessa ora dopo mezzogiorno. L'ora non viene arrotondata e se è costituita da una singola cifra viene formattata senza zero iniziale. Se viene, ad esempio, specificata un'ora equivalente alle 5:43 della mattina o del pomeriggio, tramite questo identificatore di formato personalizzato viene visualizzato "5".

Se l'identificatore di formato "h" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException. Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "h" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Torna alla tabella

Identificatore di formato personalizzato "HH"

L'identificatore di formato personalizzato "hh" (più qualsiasi numero di identificatori "h" aggiuntivi) rappresenta l'ora come numero compreso tra 01 e 12, ovvero l'ora rappresentata nell'orario in formato 12 ore in base al quale il conteggio riparte da mezzanotte o da mezzogiorno. Una particolare ora dopo mezzanotte non è distinguibile dalla stessa ora dopo mezzogiorno. L'ora non viene arrotondata e se è costituita da una singola cifra viene formattata con uno zero iniziale. Se viene, ad esempio, specificata un'ora equivalente alle 5:43 della mattina o del pomeriggio, tramite questo identificatore di formato viene visualizzato "05".

L'esempio seguente include l'identificatore di formato personalizzato "hh" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Torna alla tabella

Identificatore di formato dell'ora "H" maiuscolo

Identificatore di formato personalizzato "H"

L'identificatore di formato personalizzato "H" rappresenta l'ora come numero compreso tra 0 e 23, ovvero l'ora rappresentata nell'orario in formato 24 ore a base zero in base al quale il conteggio riparte da mezzanotte. Un'ora costituita da una singola cifra viene formattata senza zero iniziale.

Se l'identificatore di formato "H" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException. Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "H" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("H:mm:ss",
                  CultureInfo.InvariantCulture));
// Displays 6:09:01
Dim date1 As Date = #6:09:01AM#
Console.WriteLine(date1.ToString("H:mm:ss", _
                  CultureInfo.InvariantCulture))
' Displays 6:09:01                        

Torna alla tabella

Identificatore di formato personalizzato "HH"

L'identificatore di formato personalizzato "HH" (più qualsiasi numero di identificatori "H" aggiuntivi) rappresenta l'ora come numero compreso tra 00 e 23, ovvero l'ora rappresentata nell'orario in formato 24 ore a base zero in base al quale il conteggio riparte da mezzanotte. Un'ora costituita da una singola cifra viene formattata con uno zero iniziale.

L'esempio seguente include l'identificatore di formato personalizzato "HH" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("HH:mm:ss",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01
Dim date1 As Date = #6:09:01AM#
Console.WriteLine(date1.ToString("HH:mm:ss", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01                        

Torna alla tabella

Identificatore di formato "K" del fuso orario

Identificatore di formato personalizzato "K"

L'identificatore di formato personalizzato "K" rappresenta le informazioni sul fuso orario di un valore di data e ora. Quando questo identificatore di formato viene usato con valori DateTime, la stringa di risultato viene definita dal valore della proprietà DateTime.Kind:

  • Per il fuso orario locale (un valore della proprietà DateTime.Kind uguale a DateTimeKind.Local) questo identificatore è equivalente all'identificatore "zzz" e genera una stringa di risultato che contiene l'offset locale rispetto all'ora UTC (Coordinated Universal Time), ad esempio "-07.00".

  • Per un'ora UTC (un valore della proprietà DateTime.Kind uguale a DateTimeKind.Utc) la stringa di risultato include un carattere "Z" per rappresentare una data UTC.

  • Per un'ora di un fuso orario non specificato (un'ora la cui proprietà DateTime.Kind è uguale a DateTimeKind.Unspecified) il risultato è equivalente a String.Empty.

Per i valori DateTimeOffset, l'identificatore di formato "K" è equivalente all'identificatore di formato "zzz" e genera una stringa di risultato che contiene l'offset del valore DateTimeOffset rispetto a UTC.

Se l'identificatore di formato "K" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException. Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

Nell'esempio seguente viene visualizzata la stringa risultante dall'utilizzo dell'identificatore di formato personalizzato "K" con vari valori DateTime e DateTimeOffset in un sistema nel fuso Ora solare Pacifico (Stati Uniti).

Console.WriteLine(DateTime.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTime.UtcNow.ToString("%K"));
// Displays Z
Console.WriteLine("'{0}'",
                  DateTime.SpecifyKind(DateTime.Now,
                       DateTimeKind.Unspecified).ToString("%K"));
// Displays ''
Console.WriteLine(DateTimeOffset.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"));
// Displays +00:00
Console.WriteLine(new DateTimeOffset(2008, 5, 1, 6, 30, 0,
                      new TimeSpan(5, 0, 0)).ToString("%K"));
// Displays +05:00
Console.WriteLine(Date.Now.ToString("%K"))
' Displays -07:00
Console.WriteLine(Date.UtcNow.ToString("%K"))
' Displays Z      
Console.WriteLine("'{0}'", _
                  Date.SpecifyKind(Date.Now, _
                                   DateTimeKind.Unspecified). _
                  ToString("%K"))
' Displays ''      
Console.WriteLine(DateTimeOffset.Now.ToString("%K"))
' Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"))
' Displays +00:00
Console.WriteLine(New DateTimeOffset(2008, 5, 1, 6, 30, 0, _
                                     New TimeSpan(5, 0, 0)). _
                  ToString("%K"))
' Displays +05:00                        

Torna alla tabella

Identificatore di formato minuto "m"

Identificatore di formato personalizzato "m"

L'identificatore di formato personalizzato "m" rappresenta i minuti come numero compreso tra 0 e 59. Tali minuti rappresentano il numero intero di minuti passati dall'ultima ora. Un minuto costituito da una singola cifra viene formattato senza zero iniziale.

Se l'identificatore di formato "m" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "m". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "m" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Torna alla tabella

Identificatore di formato personalizzato "mm"

L'identificatore di formato personalizzato "mm" (più qualsiasi numero di identificatori "m" aggiuntivi) rappresenta i minuti come numero compreso tra 00 e 59. Tali minuti rappresentano il numero intero di minuti passati dall'ultima ora. Un minuto costituito da una singola cifra viene formattato con uno zero iniziale.

L'esempio seguente include l'identificatore di formato personalizzato "mm" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Torna alla tabella

Identificatore di formato "M" del mese

Identificatore di formato personalizzato "M"

L'identificatore di formato personalizzato "M" rappresenta il mese come numero compreso tra 1 e 12 (o tra 1 e 13 per i calendari con 13 mesi). Un mese a una sola cifra viene formattato senza uno zero iniziale.

Se l'identificatore di formato "M" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "M". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "M" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 18);
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays (8) Aug, August
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("nl-NL")));
// Displays (8) aug, augustus
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("lv-LV")));
// Displays (8) Aug, augusts
Dim date1 As Date = #8/18/2008#
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays (8) Aug, August
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("nl-NL")))
' Displays (8) aug, augustus
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("lv-LV")))
' Displays (8) Aug, augusts                       

Torna alla tabella

Identificatore di formato personalizzato "MM"

L'identificatore di formato personalizzato "MM" rappresenta il mese come numero compreso tra 01 e 12 (o tra 1 e 13 per i calendari con 13 mesi). Un mese a una sola cifra viene formattato con uno zero iniziale.

L'esempio seguente include l'identificatore di formato personalizzato "MM" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM",
                  CultureInfo.InvariantCulture));
// 02, 01
Dim date1 As Date = #1/2/2008 6:30:15AM#

Console.WriteLine(date1.ToString("dd, MM", _
                  CultureInfo.InvariantCulture))
' 02, 01

Torna alla tabella

Identificatore di formato personalizzato "MMM"

L'identificatore di formato personalizzato "MMM" rappresenta il nome abbreviato del mese. Il nome abbreviato localizzato del mese viene recuperato dalla proprietà DateTimeFormatInfo.AbbreviatedMonthNames delle impostazioni cultura correnti o specificate.

L'esempio seguente include l'identificatore di formato personalizzato "MMM" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays ven. 29 août                                                

Torna alla tabella

Identificatore di formato personalizzato "MMMM"

L'identificatore di formato personalizzato "MMMM" rappresenta il nome completo del mese. Il nome localizzato del mese viene recuperato dalla proprietà DateTimeFormatInfo.MonthNames delle impostazioni cultura correnti o specificate.

L'esempio seguente include l'identificatore di formato personalizzato "MMMM" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("it-IT")))
' Displays venerdì 29 agosto                                          

Torna alla tabella

Identificatore di formato di secondi "s"

Identificatore di formato personalizzato "s"

L'identificatore di formato personalizzato "s" rappresenta i secondi come numero compreso tra 0 e 59. Il risultato rappresenta il numero intero di secondi passati dall'ultimo minuto. Un secondo costituito da una singola cifra viene formattato senza zero iniziale.

Se l'identificatore di formato "s" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "s". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "s" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Torna alla tabella

Identificatore di formato personalizzato "SS"

L'identificatore di formato personalizzato "ss" (più qualsiasi numero di identificatori "s" aggiuntivi) rappresenta i secondi come numero compreso tra 00 e 59. Il risultato rappresenta il numero intero di secondi passati dall'ultimo minuto. Un secondo costituito da una singola cifra viene formattato con uno zero iniziale.

L'esempio seguente include l'identificatore di formato personalizzato "ss" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Torna alla tabella

Identificatore di formato "t" meridiem

Identificatore di formato personalizzato "t"

L'identificatore di formato personalizzato "t" rappresenta il primo carattere dell'indicatore AM/PM. L'indicatore localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.AMDesignator o DateTimeFormatInfo.PMDesignator delle impostazioni cultura correnti o specificate. L'indicatore AM viene usato per tutti gli orari da 0:00:00 (mezzanotte) a 11:59:59.999. L'indicatore PM viene usato per tutti gli orari da 12:00:00 (mezzogiorno) a 23:59:59.999.

Se l'identificatore di formato "t" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato data e ora standard "t". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "t" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Torna alla tabella

Identificatore di formato personalizzato "TT"

L'identificatore di formato personalizzato "tt" (più qualsiasi numero di identificatori "t" aggiuntivi) rappresenta l'indicatore AM/PM completo. L'indicatore localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.AMDesignator o DateTimeFormatInfo.PMDesignator delle impostazioni cultura correnti o specificate. L'indicatore AM viene usato per tutti gli orari da 0:00:00 (mezzanotte) a 11:59:59.999. L'indicatore PM viene usato per tutti gli orari da 12:00:00 (mezzogiorno) a 23:59:59.999.

Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessario mantenere la distinzione tra AM e PM. Un esempio è la lingua giapponese per cui gli indicatori AM e PM differiscono in corrispondenza del secondo carattere anziché del primo.

L'esempio seguente include l'identificatore di formato personalizzato "tt" in una stringa di formato personalizzata.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Torna alla tabella

Identificatore di formato "y" dell'anno

Identificatore di formato personalizzato "y"

L'identificatore di formato personalizzato "y" rappresenta l'anno come numero a una cifra o a due cifre. Se l'anno ha più di due cifre, nel risultato vengono visualizzate solo le due cifre di ordine inferiore. Se la prima cifra di un anno a due cifre inizia con zero (ad esempio, 2008), il numero viene formattato senza zero iniziale.

Se l'identificatore di formato "y" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "y". Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "y" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Torna alla tabella

Identificatore di formato personalizzato "yy"

L'identificatore 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 a due cifre ha meno di due cifre significative, al numero vengono anteposti tanti zeri quanti sono necessari per ottenere due cifre.

In un'operazione di analisi, un anno a due cifre analizzato usando l'identificatore di formato personalizzato "yy" viene interpretato in base alla proprietà Calendar.TwoDigitYearMax del calendario corrente del provider di formato. Nell'esempio seguente viene analizzata la rappresentazione di stringa di una data con un anno a due cifre usando il calendario gregoriano predefinito delle impostazioni cultura en-US, che, in questo caso, sono le impostazioni cultura correnti. Modifica quindi l'oggetto CultureInfo delle impostazioni cultura correnti per usare un oggetto GregorianCalendar la cui proprietà TwoDigitYearMax è stata modificata.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      string fmt = "dd-MMM-yy";
      string value = "24-Jan-49";

      Calendar cal = (Calendar) CultureInfo.CurrentCulture.Calendar.Clone();
      Console.WriteLine("Two Digit Year Range: {0} - {1}",
                        cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);

      Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
      Console.WriteLine();

      cal.TwoDigitYearMax = 2099;
      CultureInfo culture = (CultureInfo) CultureInfo.CurrentCulture.Clone();
      culture.DateTimeFormat.Calendar = cal;
      Thread.CurrentThread.CurrentCulture = culture;

      Console.WriteLine("Two Digit Year Range: {0} - {1}",
                        cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);
      Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
   }
}
// The example displays the following output:
//       Two Digit Year Range: 1930 - 2029
//       1/24/1949
//
//       Two Digit Year Range: 2000 - 2099
//       1/24/2049
Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        Dim fmt As String = "dd-MMM-yy"
        Dim value As String = "24-Jan-49"

        Dim cal As Calendar = CType(CultureInfo.CurrentCulture.Calendar.Clone(), Calendar)
        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax)

        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, Nothing))
        Console.WriteLine()

        cal.TwoDigitYearMax = 2099
        Dim culture As CultureInfo = CType(CultureInfo.CurrentCulture.Clone(), CultureInfo)
        culture.DateTimeFormat.Calendar = cal
        Thread.CurrentThread.CurrentCulture = culture

        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax)
        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, Nothing))
    End Sub
End Module
' The example displays the following output:
'       Two Digit Year Range: 1930 - 2029
'       1/24/1949
'       
'       Two Digit Year Range: 2000 - 2099
'       1/24/2049

L'esempio seguente include l'identificatore di formato personalizzato "yy" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Torna alla tabella

Identificatore di formato personalizzato "yyy"

L'identificatore di formato personalizzato "yyy" rappresenta l'anno con un minimo di tre cifre. Se l'anno ha più di tre cifre significative, queste vengono incluse nella stringa di risultato. Se l'anno ha meno di tre cifre, al numero vengono anteposti tanti zeri quanti sono necessari per ottenere tre cifre.

Nota

Per il calendario buddista tailandese, in cui sono previsti anni di cinque cifre, questo identificatore di formato consente di visualizzare tutte le cifre significative.

L'esempio seguente include l'identificatore di formato personalizzato "yyy" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Torna alla tabella

Identificatore di formato personalizzato "yyyy"

L'identificatore di formato personalizzato "yyyy" rappresenta l'anno con un minimo di quattro cifre. Se l'anno ha più di quattro cifre significative, queste vengono incluse nella stringa di risultato. Se l'anno ha meno di quattro cifre, al numero vengono anteposti tanti zeri quanti sono necessari per ottenere quattro cifre.

Nota

Per il calendario buddista tailandese, in cui sono previsti anni di cinque cifre, questo identificatore di formato visualizza un minimo di quattro cifre.

L'esempio seguente include l'identificatore di formato personalizzato "yyyy" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Torna alla tabella

Identificatore di formato personalizzato "yyyyy"

L'identificatore di formato personalizzato "yyyyy" (più qualsiasi numero di identificatori "y" aggiuntivi) rappresenta l'anno con un minimo di cinque cifre. Se l'anno ha più di cinque cifre significative, queste vengono incluse nella stringa di risultato. Se l'anno ha meno di cinque cifre, al numero vengono anteposti tanti zeri quanto sono necessari per ottenere cinque cifre.

Se sono presenti identificatori "y" aggiuntivi, al numero vengono anteposti tanti zeri quanti sono necessari per ottenere il numero di identificatori "y".

L'esempio seguente include l'identificatore di formato personalizzato "yyyyy" in una stringa di formato personalizzata.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Torna alla tabella

Identificatore di formato "z" offset

Identificatore di formato personalizzato "z"

Con valori DateTime, l'identificatore di formato personalizzato "z" rappresenta l'offset con segno del fuso orario del sistema operativo locale rispetto a UTC (Coordinated Universal Time), misurato in ore. Non riflette il valore della proprietà DateTime.Kind di un'istanza. Per questo motivo non è consigliabile usare l'identificatore di formato "z" con valori DateTime.

Con valori DateTimeOffset, questo identificatore di formato rappresenta l'offset del valore DateTimeOffset rispetto a UTC, in ore.

Lo scarto viene visualizzato sempre con un segno iniziale. Un segno più (+) indica le ore in più e un segno meno (-) le ore in meno rispetto all'ora UTC. Un valore di offset a una sola cifra viene formattato senza uno zero iniziale.

Se l'identificatore di formato "z" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException. Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

L'esempio seguente include l'identificatore di formato personalizzato "z" in una stringa di formato personalizzata.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00                     

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Torna alla tabella

Identificatore di formato personalizzato "ZZ"

Con valori DateTime, l'identificatore di formato personalizzato "zz" rappresenta l'offset con segno del fuso orario del sistema operativo locale rispetto a UTC, misurato in ore. Non riflette il valore della proprietà DateTime.Kind di un'istanza. Per questo motivo, non è consigliabile usare l'identificatore di formato "zz" con valori DateTime.

Con valori DateTimeOffset, questo identificatore di formato rappresenta l'offset del valore DateTimeOffset rispetto a UTC, in ore.

Lo scarto viene visualizzato sempre con un segno iniziale. Un segno più (+) indica le ore in più e un segno meno (-) le ore in meno rispetto all'ora UTC. Un valore di offset di una sola cifra viene formattato con uno zero iniziale.

L'esempio seguente include l'identificatore di formato personalizzato "zz" in una stringa di formato personalizzata.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00                     

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Torna alla tabella

Identificatore di formato personalizzato "zzz"

Con valori DateTime, l'identificatore di formato personalizzato "zzz" rappresenta l'offset con segno del fuso orario del sistema operativo locale rispetto a UTC, misurato in ore e minuti. Non riflette il valore della proprietà DateTime.Kind di un'istanza. Per questo motivo, non è consigliabile usare l'identificatore di formato "zzz" con valori DateTime.

Con valori DateTimeOffset, questo identificatore di formato rappresenta l'offset del valore DateTimeOffset rispetto a UTC, in ore e minuti.

Lo scarto viene visualizzato sempre con un segno iniziale. Un segno più (+) indica le ore in più e un segno meno (-) le ore in meno rispetto all'ora UTC. Un valore di offset di una sola cifra viene formattato con uno zero iniziale.

L'esempio seguente include l'identificatore di formato personalizzato "zzz" in una stringa di formato personalizzata.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00                     

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Torna alla tabella

Identificatori di separatori di data e ora

Identificatore di formato personalizzato ":"

L'identificatore di formato personalizzato ":" rappresenta il separatore di ora che viene usato per distinguere ore, minuti e secondi. Il separatore di ora localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.TimeSeparator delle impostazioni cultura correnti o specificate.

Nota

Per modificare il separatore dell'ora per una particolare stringa di data e ora, specificare il carattere separatore all'interno di un delimitatore di stringa letterale. La stringa con formato personalizzato hh'_'dd'_'ss, ad esempio, produce una stringa in cui "_" (carattere di sottolineatura) è sempre usato come separatore dell'ora. Per cambiare il separatore dell'ora per tutte le date per una impostazione cultura, modificare il valore della proprietà DateTimeFormatInfo.TimeSeparator per l'impostazione cultura attuale oppure creare un'istanza di un oggetto DateTimeFormatInfo, assegnare il carattere alla relativa proprietà TimeSeparator e chiamare un overload del metodo di formattazione che include un parametro IFormatProvider.

Se l'identificatore di formato ":" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException. Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

Torna alla tabella

Identificatore di formato personalizzato "/"

L'identificatore di formato personalizzato "/" rappresenta il separatore di data usato per distinguere anni, mesi e giorni. Il separatore di data localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.DateSeparator delle impostazioni cultura correnti o specificate.

Nota

Per modificare il separatore della data per una particolare stringa di data e ora, specificare il carattere separatore all'interno di un delimitatore di stringa letterale. Ad esempio, la stringa con formato personalizzato mm'/'dd'/'yyyy produce una stringa in cui "/" è sempre usato come separatore dell'ora. Per cambiare il separatore della data per tutte le date per una impostazione cultura, modificare il valore della proprietà DateTimeFormatInfo.DateSeparator per l'impostazione cultura attuale oppure creare un'istanza di un oggetto DateTimeFormatInfo, assegnare il carattere alla relativa proprietà DateSeparator e chiamare un overload del metodo di formattazione che include un parametro IFormatProvider.

Se l'identificatore di formato "/" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException. Per altre informazioni sull'uso di un singolo identificatore di formato, vedere Uso di singoli identificatori di formato personalizzati più avanti in questo articolo.

Torna alla tabella

Valori letterali carattere

I caratteri seguenti in una stringa di formato di data e ora personalizzato sono riservati e vengono sempre interpretati come caratteri di formattazione o, nel caso di " ,, ' / e \ , come caratteri speciali.

F H K M d
f g h m s
t y z % :
/ " ' \

Tutti gli altri caratteri vengono sempre interpretati come valori letterali carattere e in un'operazione di formattazione vengono inclusi senza modifiche nella stringa di risultato. In un'operazione di analisi questi caratteri devono corrispondere esattamente ai caratteri nella stringa di input. Il confronto tiene conto di maiuscole e minuscole.

Nell'esempio seguente i caratteri "PST" (abbreviazione di Pacific Standard Time, Ora solare Pacifico) e "PDT" (abbreviazione di Pacific Daylight Time, Ora legale Pacifico) rappresentano il fuso orario locale in una stringa di formato. Si noti che la stringa è inclusa nella stringa di risultato e che una stringa che include la stringa del fuso orario locale viene analizzata correttamente.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] formats = { "dd MMM yyyy hh:mm tt PST",
                           "dd MMM yyyy hh:mm tt PDT" };
      var dat = new DateTime(2016, 8, 18, 16, 50, 0);
      // Display the result string.
      Console.WriteLine(dat.ToString(formats[1]));

      // Parse a string.
      String value = "25 Dec 2016 12:00 pm PST";
      DateTime newDate;
      if (DateTime.TryParseExact(value, formats, null,
                                 DateTimeStyles.None, out newDate))
         Console.WriteLine(newDate);
      else
         Console.WriteLine("Unable to parse '{0}'", value);
   }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM PDT
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim formats() As String = {"dd MMM yyyy hh:mm tt PST",
                                    "dd MMM yyyy hh:mm tt PDT"}
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(formats(1)))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm PST"
        Dim newDate As Date
        If Date.TryParseExact(value, formats, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM PDT
'       12/25/2016 12:00:00 PM

Esistono due modi per indicare che determinati caratteri devono essere interpretati come caratteri e non come caratteri riservati, per includerli in una stringa di risultato o eseguirne l'analisi in una stringa di input:

Nell'esempio seguente i caratteri "pst" (abbreviazione di Pacific Standard Time, Ora solare Pacifico) rappresentano il fuso orario locale in una stringa di formato. Poiché sia "s" che "t" sono stringhe di formato personalizzato, perché siano interpretate come valori letterali carattere è necessario usare un carattere di escape per entrambe.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String format = "dd MMM yyyy hh:mm tt p\\s\\t";
      var dat = new DateTime(2016, 8, 18, 16, 50, 0);
      // Display the result string.
      Console.WriteLine(dat.ToString(format));

      // Parse a string.
      String value = "25 Dec 2016 12:00 pm pst";
      DateTime newDate;
      if (DateTime.TryParseExact(value, format, null,
                                 DateTimeStyles.None, out newDate))
         Console.WriteLine(newDate);
      else
         Console.WriteLine("Unable to parse '{0}'", value);
   }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM PDT
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim fmt As String = "dd MMM yyyy hh:mm tt p\s\t"
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(fmt))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm pst"
        Dim newDate As Date
        If Date.TryParseExact(value, fmt, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM pst
'       12/25/2016 12:00:00 PM
  • Racchiudendo l'intera stringa tra virgolette o apostrofi. L'esempio seguente è simile a quello precedente, ad eccezione del fatto che "pst" è racchiuso tra virgolette per indicare che l'intera stringa delimitata deve essere interpretata come insieme di valori letterali carattere.
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String format = "dd MMM yyyy hh:mm tt \"pst\"";
      var dat = new DateTime(2016, 8, 18, 16, 50, 0);
      // Display the result string.
      Console.WriteLine(dat.ToString(format));

      // Parse a string.
      String value = "25 Dec 2016 12:00 pm pst";
      DateTime newDate;
      if (DateTime.TryParseExact(value, format, null,
                                 DateTimeStyles.None, out newDate))
         Console.WriteLine(newDate);
      else
         Console.WriteLine("Unable to parse '{0}'", value);
   }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM PDT
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim fmt As String = "dd MMM yyyy hh:mm tt ""pst"""
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(fmt))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm pst"
        Dim newDate As Date
        If Date.TryParseExact(value, fmt, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM pst
'       12/25/2016 12:00:00 PM

Note

Uso di singoli identificatori di formato personalizzati

Una stringa di formato di data e ora personalizzata è costituita da due o più caratteri. I metodi di formattazione di data e ora interpretano qualsiasi stringa a carattere singolo come stringa di formato di data e ora standard. Se il carattere non viene riconosciuto come identificatore di formato valido, viene generato un evento FormatException. Una stringa di formato costituita solo dall'identificatore "h" viene ad esempio interpretata come una stringa di formato di data e ora standard. In questo caso specifico, tuttavia, viene generata un'eccezione in quanto non vi è alcun identificatore di formato di data e ora standard "h".

Per usare qualsiasi identificatore di formato di data e ora personalizzato come unico identificatore in una stringa di formato (ovvero, per usare l'identificatore di formato personalizzato "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":" o "/" da solo), includere uno spazio prima o dopo l'identificatore oppure includere un identificatore di formato percentuale ("%") prima del singolo identificatore di data e ora personalizzato.

La stringa %h" viene ad esempio interpretata come una stringa di formato di data e ora personalizzata che consente di visualizzare l'ora rappresentata dal valore di data e ora corrente. È anche possibile usare la stringa di formato " h" o "h ", sebbene, in questo caso, verrà incluso uno spazio nella stringa di risultato insieme all'ora. Nell'esempio seguente vengono illustrate queste tre stringhe di formato.

DateTime dat1 = new DateTime(2009, 6, 15, 13, 45, 0);

Console.WriteLine("'{0:%h}'", dat1);
Console.WriteLine("'{0: h}'", dat1);
Console.WriteLine("'{0:h }'", dat1);
// The example displays the following output:
//       '1'
//       ' 1'
//       '1 '
Dim dat1 As Date = #6/15/2009 1:45PM#

Console.WriteLine("'{0:%h}'", dat1)
Console.WriteLine("'{0: h}'", dat1)
Console.WriteLine("'{0:h }'", dat1)
' The example displays the following output:
'       '1'
'       ' 1'
'       '1 '

Uso del carattere di escape

I caratteri "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":" o "/" in una stringa di formato vengono interpretati come identificatori di formato personalizzati anziché come caratteri letterali. Per evitare che un carattere venga interpretato come identificatore di formato, è possibile anteporvi una barra rovesciata (\), che rappresenta il carattere di escape. Il carattere di escape indica che il carattere seguente è un valore letterale carattere che deve essere incluso nella stringa di risultato senza modifiche.

Per includere una barra rovesciata in una stringa dei risultati, è necessario aggiungere un carattere di escape facendolo quindi precedere da un'altra barra rovesciata (\\).

Nota

Alcuni compilatori, ad esempio i compilatori C++ e C#, possono anche interpretare un singolo carattere barra rovesciata come carattere di escape. Per assicurarsi che una stringa venga interpretata correttamente quando viene eseguita la formattazione, è possibile usare il carattere del valore letterale stringa letterale (carattere @) prima della stringa in C# o aggiungere un altro carattere barra rovesciata prima di ogni barra rovesciata in C# e C++. Nell'esempio C# seguente vengono illustrati entrambi gli approcci.

Nell'esempio seguente viene usato il carattere di escape per impedire che durante l'operazione di formattazione i caratteri "h" e "m" vengano interpretati come identificatori di formato.

DateTime date = new DateTime(2009, 06, 15, 13, 45, 30, 90);
string fmt1 = "h \\h m \\m";
string fmt2 = @"h \h m \m";

Console.WriteLine("{0} ({1}) -> {2}", date, fmt1, date.ToString(fmt1));
Console.WriteLine("{0} ({1}) -> {2}", date, fmt2, date.ToString(fmt2));
// The example displays the following output:
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m
Dim date1 As Date = #6/15/2009 13:45#
Dim fmt As String = "h \h m \m"

Console.WriteLine("{0} ({1}) -> {2}", date1, fmt, date1.ToString(fmt))
' The example displays the following output:
'       6/15/2009 1:45:00 PM (h \h m \m) -> 1 h 45 m      

Impostazioni del Pannello di controllo

L'impostazione Opzioni internazionali e della lingua nel Pannello di controllo influisce sulla stringa di risultato prodotta da un'operazione di formattazione che include molti degli identificatori di formato di data e ora personalizzati. Queste impostazioni vengono usate per inizializzare l'oggetto DateTimeFormatInfo associato alle impostazioni cultura del thread corrente, che fornisce i valori usati per definire la formattazione. Computer con impostazioni diverse generano stringhe di risultato diverse.

Se inoltre viene usato il costruttore CultureInfo(String) per creare un'istanza di un nuovo oggetto CultureInfo che rappresenta le stesse impostazioni cultura delle impostazioni cultura del sistema correnti, le eventuali personalizzazioni definite tramite Opzioni internazionali e della lingua nel Pannello di controllo verranno applicate al nuovo oggetto CultureInfo . È possibile usare il costruttore CultureInfo(String, Boolean) per creare un oggetto CultureInfo che non rifletta le personalizzazioni di un sistema.

Proprietà DateTimeFormatInfo

La formattazione è influenzata dalle proprietà dell'oggetto DateTimeFormatInfo corrente, che viene fornito in modo implicito dalle impostazioni cultura del thread correnti o in modo esplicito dal parametro IFormatProvider del metodo che richiama la formattazione. Per il parametro IFormatProvider, è necessario specificare un oggetto CultureInfo, che rappresenta determinate impostazioni cultura o un oggetto DateTimeFormatInfo.

La stringa di risultato prodotta da molti degli identificatori di formato di data e ora personalizzati dipende anche dalle proprietà dell'oggetto DateTimeFormatInfo corrente. Nell'applicazione può quindi essere modificato il risultato prodotto da alcuni identificatori di formato di data e ora personalizzati modificando la proprietà DateTimeFormatInfo corrispondente. L'identificatore di formato "ddd" aggiunge, ad esempio, un nome di giorno della settimana abbreviato trovato nella matrice di stringhe AbbreviatedDayNames alla stringa di risultato. In modo analogo, l'identificatore di formato "MMMM" aggiunge alla stringa di risultato un nome del mese completo trovato nella matrice di stringhe MonthNames.

Vedi anche