# Formattazione DateTime
Formattazione DateTime standard
DateTimeFormatInfo specifica un set di identificatori per la semplice formattazione di data e ora. Ogni specificatore corrisponde a un particolare modello di formato DateTimeFormatInfo.
//Create datetime
DateTime dt = new DateTime(2016,08,01,18,50,23,230);
var t = String.Format("{0:t}", dt); // "6:50 PM" ShortTime
var d = String.Format("{0:d}", dt); // "8/1/2016" ShortDate
var T = String.Format("{0:T}", dt); // "6:50:23 PM" LongTime
var D = String.Format("{0:D}", dt); // "Monday, August 1, 2016" LongDate
var f = String.Format("{0:f}", dt); // "Monday, August 1, 2016 6:50 PM" LongDate+ShortTime
var F = String.Format("{0:F}", dt); // "Monday, August 1, 2016 6:50:23 PM" FullDateTime
var g = String.Format("{0:g}", dt); // "8/1/2016 6:50 PM" ShortDate+ShortTime
var G = String.Format("{0:G}", dt); // "8/1/2016 6:50:23 PM" ShortDate+LongTime
var m = String.Format("{0:m}", dt); // "August 1" MonthDay
var y = String.Format("{0:y}", dt); // "August 2016" YearMonth
var r = String.Format("{0:r}", dt); // "SMon, 01 Aug 2016 18:50:23 GMT" RFC1123
var s = String.Format("{0:s}", dt); // "2016-08-01T18:50:23" SortableDateTime
var u = String.Format("{0:u}", dt); // "2016-08-01 18:50:23Z" UniversalSortableDateTime
Formattazione DateTime personalizzata
Sono disponibili i seguenti identificatori di formato personalizzati:
y(anno)M(mese)d(giorno)h(ora 12)H(ora 24)m(minuto)s(secondo)f(seconda frazione)F(seconda frazione, gli zeri finali vengono tagliati)t(P.M o A.M)z(fuso orario).
var year = String.Format("{0:y yy yyy yyyy}", dt); // "16 16 2016 2016" year
var month = String.Format("{0:M MM MMM MMMM}", dt); // "8 08 Aug August" month
var day = String.Format("{0:d dd ddd dddd}", dt); // "1 01 Mon Monday" day
var hour = String.Format("{0:h hh H HH}", dt); // "6 06 18 18" hour 12/24
var minute = String.Format("{0:m mm}", dt); // "50 50" minute
var secound = String.Format("{0:s ss}", dt); // "23 23" second
var fraction = String.Format("{0:f ff fff ffff}", dt); // "2 23 230 2300" sec.fraction
var fraction2 = String.Format("{0:F FF FFF FFFF}", dt); // "2 23 23 23" without zeroes
var period = String.Format("{0:t tt}", dt); // "P PM" A.M. or P.M.
var zone = String.Format("{0:z zz zzz}", dt); // "+0 +00 +00:00" time zone
Puoi anche usare il separatore di data / (barra) e separatore di tempo : (due punti).
Per esempio di codice
Per ulteriori informazioni MSDN .
# DateTime.AddDays(Double)
Aggiungi giorni in un oggetto dateTime.
DateTime today = DateTime.Now;
DateTime answer = today.AddDays(36);
Console.WriteLine("Today: {0:dddd}", today);
Console.WriteLine("36 days from today: {0:dddd}", answer);
Puoi anche sottrarre i giorni che passano un valore negativo:
DateTime today = DateTime.Now;
DateTime answer = today.AddDays(-3);
Console.WriteLine("Today: {0:dddd}", today);
Console.WriteLine("-3 days from today: {0:dddd}", answer);
# DateTime.AddHours(Double)
double[] hours = {.08333, .16667, .25, .33333, .5, .66667, 1, 2,
29, 30, 31, 90, 365};
DateTime dateValue = new DateTime(2009, 3, 1, 12, 0, 0);
foreach (double hour in hours)
Console.WriteLine("{0} + {1} hour(s) = {2}", dateValue, hour,
dateValue.AddHours(hour));
# DateTime.Parse(String)
// Converts the string representation of a date and time to its DateTime equivalent
var dateTime = DateTime.Parse("14:23 22 Jul 2016");
Console.WriteLine(dateTime.ToString());
# DateTime.TryParse(String, DateTime)
// Converts the specified string representation of a date and time to its DateTime equivalent and returns a value that indicates whether the conversion succeeded
string[] dateTimeStrings = new []{
"14:23 22 Jul 2016",
"99:23 2x Jul 2016",
"22/7/2016 14:23:00"
};
foreach(var dateTimeString in dateTimeStrings){
DateTime dateTime;
bool wasParsed = DateTime.TryParse(dateTimeString, out dateTime);
string result = dateTimeString +
(wasParsed
? $"was parsed to {dateTime}"
: "can't be parsed to DateTime");
Console.WriteLine(result);
}
# DateTime.AddMilliseconds(Double)
string dateFormat = "MM/dd/yyyy hh:mm:ss.fffffff";
DateTime date1 = new DateTime(2010, 9, 8, 16, 0, 0);
Console.WriteLine("Original date: {0} ({1:N0} ticks)\n",
date1.ToString(dateFormat), date1.Ticks);
DateTime date2 = date1.AddMilliseconds(1);
Console.WriteLine("Second date: {0} ({1:N0} ticks)",
date2.ToString(dateFormat), date2.Ticks);
Console.WriteLine("Difference between dates: {0} ({1:N0} ticks)\n",
date2 - date1, date2.Ticks - date1.Ticks);
DateTime date3 = date1.AddMilliseconds(1.5);
Console.WriteLine("Third date: {0} ({1:N0} ticks)",
date3.ToString(dateFormat), date3.Ticks);
Console.WriteLine("Difference between dates: {0} ({1:N0} ticks)",
date3 - date1, date3.Ticks - date1.Ticks);
# DateTime.Compare(DateTime t1, DateTime t2 )
DateTime date1 = new DateTime(2009, 8, 1, 0, 0, 0);
DateTime date2 = new DateTime(2009, 8, 1, 12, 0, 0);
int result = DateTime.Compare(date1, date2);
string relationship;
if (result < 0)
relationship = "is earlier than";
else if (result == 0)
relationship = "is the same time as";
else relationship = "is later than";
Console.WriteLine("{0} {1} {2}", date1, relationship, date2);
# DateTime.DaysInMonth(Int32, Int32)
const int July = 7;
const int Feb = 2;
int daysInJuly = System.DateTime.DaysInMonth(2001, July);
Console.WriteLine(daysInJuly);
// daysInFeb gets 28 because the year 1998 was not a leap year.
int daysInFeb = System.DateTime.DaysInMonth(1998, Feb);
Console.WriteLine(daysInFeb);
// daysInFebLeap gets 29 because the year 1996 was a leap year.
int daysInFebLeap = System.DateTime.DaysInMonth(1996, Feb);
Console.WriteLine(daysInFebLeap);
# DateTime.AddYears(Int32)
Aggiungi anni sull'oggetto dateTime:
DateTime baseDate = new DateTime(2000, 2, 29);
Console.WriteLine("Base Date: {0:d}\n", baseDate);
// Show dates of previous fifteen years.
for (int ctr = -1; ctr >= -15; ctr--)
Console.WriteLine("{0,2} year(s) ago:{1:d}",
Math.Abs(ctr), baseDate.AddYears(ctr));
Console.WriteLine();
// Show dates of next fifteen years.
for (int ctr = 1; ctr <= 15; ctr++)
Console.WriteLine("{0,2} year(s) from now: {1:d}",
ctr, baseDate.AddYears(ctr));
# Avviso di funzioni pure quando si ha a che fare con DateTime
Wikipedia attualmente definisce una funzione pura come segue:
- La funzione valuta sempre lo stesso valore di risultato dati gli stessi valori di argomento. Il valore del risultato della funzione non può dipendere da alcuna informazione nascosta o stato che può cambiare durante l'esecuzione del programma o tra diverse esecuzioni del programma, né può dipendere da alcun input esterno dai dispositivi I/O.
- La valutazione del risultato non provoca alcun effetto collaterale o output semanticamente osservabile, come la mutazione di oggetti mutabili o l'output su dispositivi I/O
Come sviluppatore devi essere consapevole dei metodi puri e ti imbatterai spesso in questi in molte aree. Uno che ho visto che morde molti sviluppatori junior è lavorare con i metodi della classe DateTime. Molti di questi sono puri e se non ne sei a conoscenza puoi essere sorpreso. Un esempio:
DateTime sample = new DateTime(2016, 12, 25);
sample.AddDays(1);
Console.WriteLine(sample.ToShortDateString());
Dato l'esempio sopra, ci si potrebbe aspettare che il risultato stampato sulla console sia "26/12/2016", ma in realtà si finisce con la stessa data. Questo perché AddDays è un metodo puro e non influisce sulla data originale. Per ottenere l'output previsto dovresti modificare la chiamata AddDays come segue:
sample = sample.AddDays(1);
# DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)
Converte la rappresentazione di stringa specificata di una data e un'ora nell'equivalente DateTime usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e lo stile specificati. Il formato della rappresentazione della stringa deve corrispondere esattamente al formato specificato. Il metodo restituisce un valore che indica se la conversione è riuscita.
Ad esempio
CultureInfo enUS = new CultureInfo("en-US");
string dateString;
System.DateTime dateValue;
Analizza la data senza flag di stile.
dateString = " 5/01/2009 8:30 AM";
if (DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.None, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
}
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
if(DateTime.TryParseExact(dateString, "g", enUS, DateTimeStyles.AllowLeadingWhite, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
Usa formati personalizzati con M e MM.
dateString = "5/01/2009 09:00";
if(DateTime.TryParseExact(dateString, "M/dd/yyyy hh:mm", enUS, DateTimeStyles.None, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
}
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
if(DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm", enUS, DateTimeStyles.None, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
}
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
Analizza una stringa con informazioni sul fuso orario.
dateString = "05/01/2009 01:30:42 PM -05:00";
if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.None, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
}
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
// Allow a leading space in the date string.
if (DateTime.TryParseExact(dateString, "MM/dd/yyyy hh:mm:ss tt zzz", enUS, DateTimeStyles.AdjustToUniversal, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
}
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
Analizza una stringa che rappresenta l'UTC.
dateString = "2008-06-11T16:11:20.0904778Z";
if(DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.None, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
}
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
if (DateTime.TryParseExact(dateString, "o", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateValue))
{
Console.WriteLine("Converted '{0}' to {1} ({2}).", dateString, dateValue, dateValue.Kind);
}
else
{
Console.WriteLine("'{0}' is not in an acceptable format.", dateString);
}
Uscite
' 5/01/2009 8:30 AM' is not in an acceptable format.
Converted ' 5/01/2009 8:30 AM' to 5/1/2009 8:30:00 AM (Unspecified).
Converted '5/01/2009 09:00' to 5/1/2009 9:00:00 AM (Unspecified).
'5/01/2009 09:00' is not in an acceptable format.
Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 11:30:42 AM (Local).
Converted '05/01/2009 01:30:42 PM -05:00' to 5/1/2009 6:30:42 PM (Utc).
Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 9:11:20 AM (Local).
Converted '2008-06-11T16:11:20.0904778Z' to 6/11/2008 4:11:20 PM (Utc).
# DateTime.Add(TimeSpan)
// Calculate what day of the week is 36 days from this instant.
System.DateTime today = System.DateTime.Now;
System.TimeSpan duration = new System.TimeSpan(36, 0, 0, 0);
System.DateTime answer = today.Add(duration);
System.Console.WriteLine("{0:dddd}", answer);
# Analizza e prova analizza con informazioni sulla cultura
Potresti volerlo utilizzare durante l'analisi di DateTimes da culture (lingue) diverse, l'esempio seguente analizza la data olandese.
DateTime dateResult;
var dutchDateString = "31 oktober 1999 04:20";
var dutchCulture = CultureInfo.CreateSpecificCulture("nl-NL");
DateTime.TryParse(dutchDateString, dutchCulture, styles, out dateResult);
// output {31/10/1999 04:20:00}
Esempio di analisi:
DateTime.Parse(dutchDateString, dutchCulture)
// output {31/10/1999 04:20:00}
# DateTime come inizializzatore nel ciclo for
// This iterates through a range between two DateTimes
// with the given iterator (any of the Add methods)
DateTime start = new DateTime(2016, 01, 01);
DateTime until = new DateTime(2016, 02, 01);
// NOTICE: As the add methods return a new DateTime you have
// to overwrite dt in the iterator like dt = dt.Add()
for (DateTime dt = start; dt < until; dt = dt.AddDays(1))
{
Console.WriteLine("Added {0} days. Resulting DateTime: {1}",
(dt - start).Days, dt.ToString());
}
Esecuzione dell'iterazione su un TimeSpan funziona allo stesso modo.
# DateTime ToString, ToShortDateString, ToLongDateString e ToString formattati
using System;
public class Program
{
public static void Main()
{
var date = new DateTime(2016,12,31);
Console.WriteLine(date.ToString()); //Outputs: 12/31/2016 12:00:00 AM
Console.WriteLine(date.ToShortDateString()); //Outputs: 12/31/2016
Console.WriteLine(date.ToLongDateString()); //Outputs: Saturday, December 31, 2016
Console.WriteLine(date.ToString("dd/MM/yyyy")); //Outputs: 31/12/2016
}
}
# Data corrente
Per ottenere la data corrente usi il DateTime.Today proprietà. Questo restituisce un DateTime oggetto con data odierna. Quando questo viene convertito in .ToString() lo fa nella località del tuo sistema per impostazione predefinita.
Ad esempio:
Console.WriteLine(DateTime.Today);
Scrive la data odierna, nel tuo formato locale sulla console.
# DateTime.ParseExact(String, String, IFormatProvider)
Converte la rappresentazione di stringa specificata di una data e un'ora nell'equivalente DateTime usando il formato specificato e le informazioni sul formato specifiche delle impostazioni cultura. Il formato della rappresentazione della stringa deve corrispondere esattamente al formato specificato.
Convertire una stringa di formato specifica in DateTime equivalente
Supponiamo di avere una stringa DateTime specifica per le impostazioni cultura 08-07-2016 11:30:12 PM come MM-dd-yyyy hh:mm:ss tt formato e vogliamo che venga convertito nell'equivalente DateTime oggetto
string str = "08-07-2016 11:30:12 PM";
DateTime date = DateTime.ParseExact(str, "MM-dd-yyyy hh:mm:ss tt", CultureInfo.CurrentCulture);
Convertire una stringa di data e ora nell'equivalente DateTime oggetto senza alcun formato cultura specifico
Supponiamo di avere una stringa DateTime in dd-MM-yy hh:mm:ss tt formato e vogliamo che venga convertito nell'equivalente DateTime oggetto, senza alcuna specifica informazione culturale
string str = "17-06-16 11:30:12 PM";
DateTime date = DateTime.ParseExact(str, "dd-MM-yy hh:mm:ss tt", CultureInfo.InvariantCulture);
Convertire una stringa di data e ora in un oggetto DateTime equivalente senza alcun formato delle impostazioni cultura specifico con un formato diverso
Supponiamo di avere una stringa Date , ad esempio '23-12-2016' o '12/23/2016' e vogliamo che venga convertita nell'equivalente DateTime oggetto, senza alcuna specifica informazione culturale
string date = '23-12-2016' or date = 12/23/2016';
string[] formats = new string[] {"dd-MM-yyyy","MM/dd/yyyy"}; // even can add more possible formats.
DateTime date = DateTime.ParseExact(date,formats, CultureInfo.InvariantCulture,DateTimeStyles.None);
NOTA:System.Globalization deve essere aggiunto per CultureInfo Class