# DateTime-Formatierung
Standard-DateTime-Formatierung
DateTimeFormatInfo gibt eine Reihe von Bezeichnern für die einfache Formatierung von Datum und Uhrzeit an. Jeder Bezeichner entspricht einem bestimmten DateTimeFormatInfo-Formatmuster.
//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
Benutzerdefinierte DateTime-Formatierung
Es gibt folgende benutzerdefinierte Formatbezeichner:
y(Jahr)M(Monat)d(Tag)h(Stunde 12)H(Stunde 24)m(Minute)s(Zweite)f(zweiter Bruchteil)F(zweiter Bruchteil, nachgestellte Nullen werden abgeschnitten)t(PM oder AM)z(Zeitzone).
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
Sie können auch das Datumstrennzeichen / verwenden (Schrägstrich) und Zeittrennzeichen : (Doppelpunkt).
Für Codebeispiel
Für weitere Informationen MSDN .
# DateTime.AddDays(Double)
Fügen Sie einem dateTime-Objekt Tage hinzu.
DateTime today = DateTime.Now;
DateTime answer = today.AddDays(36);
Console.WriteLine("Today: {0:dddd}", today);
Console.WriteLine("36 days from today: {0:dddd}", answer);
Sie können auch Tage subtrahieren, wenn Sie einen negativen Wert übergeben:
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)
Fügen Sie dem dateTime-Objekt Jahre hinzu:
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));
# Reine Funktionswarnung beim Umgang mit DateTime
Wikipedia definiert derzeit eine reine Funktion wie folgt:
- Die Funktion wertet bei gleichem Argumentwert(en) immer den gleichen Ergebniswert aus. Der Ergebniswert der Funktion darf nicht von versteckten Informationen oder Zuständen abhängen, die sich während der Programmausführung oder zwischen verschiedenen Ausführungen des Programms ändern können, noch kann er von externen Eingaben von E/A-Geräten abhängen.
- Die Auswertung des Ergebnisses verursacht keine semantisch beobachtbaren Nebeneffekte oder Ausgaben, wie z. B. die Mutation von veränderlichen Objekten oder die Ausgabe an E/A-Geräte
Als Entwickler müssen Sie sich klarer Methoden bewusst sein, und Sie werden in vielen Bereichen häufig darauf stoßen. Ich habe gesehen, dass viele Junior-Entwickler mit DateTime-Klassenmethoden arbeiten. Viele davon sind rein und wenn Sie sich dessen nicht bewusst sind, können Sie eine Überraschung erleben. Ein Beispiel:
DateTime sample = new DateTime(2016, 12, 25);
sample.AddDays(1);
Console.WriteLine(sample.ToShortDateString());
In Anbetracht des obigen Beispiels kann man davon ausgehen, dass das auf der Konsole ausgegebene Ergebnis „26.12.2016“ lautet, aber in Wirklichkeit erhalten Sie dasselbe Datum. Dies liegt daran, dass AddDays eine reine Methode ist und das ursprüngliche Datum nicht beeinflusst. Um die erwartete Ausgabe zu erhalten, müssten Sie den AddDays-Aufruf wie folgt ändern:
sample = sample.AddDays(1);
# DateTime.TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)
Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit unter Verwendung des angegebenen Formats, der kulturspezifischen Formatinformationen und des angegebenen Stils in die entsprechende DateTime-Entsprechung. Das Format der Zeichenfolgendarstellung muss genau mit dem angegebenen Format übereinstimmen. Die Methode gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
Zum Beispiel
CultureInfo enUS = new CultureInfo("en-US");
string dateString;
System.DateTime dateValue;
Analysieren Sie das Datum ohne Style-Flags.
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);
}
Verwenden Sie benutzerdefinierte Formate mit M und 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);
}
Analysieren Sie eine Zeichenfolge mit Zeitzoneninformationen.
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);
}
Analysieren Sie eine Zeichenfolge, die UTC darstellt.
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);
}
Ausgänge
' 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);
# Parse und TryParse mit Kulturinformationen
Möglicherweise möchten Sie es verwenden, wenn Sie DateTimes aus verschiedenen Kulturen (Sprachen) analysieren. Das folgende Beispiel analysiert das niederländische Datum.
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}
Beispiel für Parse:
DateTime.Parse(dutchDateString, dutchCulture)
// output {31/10/1999 04:20:00}
# DateTime als Initialisierer in for-loop
// 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());
}
Iteration auf einem TimeSpan funktioniert genauso.
# DateTime ToString, ToShortDateString, ToLongDateString und ToString formatiert
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
}
}
# Aktuelles Datum
Um das aktuelle Datum zu erhalten, verwenden Sie den DateTime.Today Eigentum. Dies gibt einen DateTime zurück Objekt mit dem heutigen Datum. Wenn dies dann konvertiert wird .ToString() Dies geschieht standardmäßig in der Lokalität Ihres Systems.
Zum Beispiel:
Console.WriteLine(DateTime.Today);
Schreibt das heutige Datum in Ihrem lokalen Format auf die Konsole.
# DateTime.ParseExact(String, String, IFormatProvider)
Konvertiert die angegebene Zeichenfolgendarstellung eines Datums und einer Uhrzeit unter Verwendung des angegebenen Formats und der kulturspezifischen Formatinformationen in die entsprechende DateTime-Entsprechung. Das Format der Zeichenfolgendarstellung muss exakt mit dem angegebenen Format übereinstimmen.
Konvertieren Sie eine bestimmte Formatzeichenfolge in die entsprechende DateTime
Angenommen, wir haben eine kulturspezifische DateTime-Zeichenfolge 08-07-2016 11:30:12 PM als MM-dd-yyyy hh:mm:ss tt Format und wir möchten, dass es in das entsprechende DateTime konvertiert wird Objekt
string str = "08-07-2016 11:30:12 PM";
DateTime date = DateTime.ParseExact(str, "MM-dd-yyyy hh:mm:ss tt", CultureInfo.CurrentCulture);
Konvertieren Sie eine Datumszeitzeichenfolge in das Äquivalent DateTime Objekt ohne spezifisches Kulturformat
Nehmen wir an, wir haben eine DateTime-Zeichenfolge in dd-MM-yy hh:mm:ss tt Format und wir möchten, dass es in das entsprechende DateTime konvertiert wird Objekt, ohne spezifische Kulturinformationen
string str = "17-06-16 11:30:12 PM";
DateTime date = DateTime.ParseExact(str, "dd-MM-yy hh:mm:ss tt", CultureInfo.InvariantCulture);
Konvertieren Sie eine Datumszeitzeichenfolge in ein entsprechendes DateTime-Objekt ohne ein bestimmtes Kulturformat mit einem anderen Format
Nehmen wir an, wir haben eine Datumszeichenfolge, z. B. '23-12-2016' oder '12/23/2016', und wir möchten, dass sie in das Äquivalent DateTime konvertiert wird Objekt, ohne spezifische Kulturinformationen
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);
HINWEIS:System.Globalization muss für die CultureInfo-Klasse hinzugefügt werden