C# Language
DateTime-methoden

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);

DateTime.AddDays (Double)

Voeg dagen toe aan een dateTime-object.

DateTime today = DateTime.Now;
DateTime answer = today.AddDays(36);
Console.WriteLine("Today: {0:dddd}", today);
Console.WriteLine("36 days from today: {0:dddd}", answer);

U kunt ook dagen aftrekken die een negatieve waarde passeren:

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.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)

Jaren toevoegen aan het dateTime-object:

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));

Pure functies waarschuwing bij het omgaan met DateTime

Wikipedia definieert momenteel een pure functie als volgt:

1. De functie evalueert altijd dezelfde resultaatwaarde bij dezelfde argumentwaarde (n). De waarde van het functieresultaat kan niet afhangen van verborgen informatie of status die kan veranderen terwijl het programma wordt uitgevoerd of tussen verschillende uitvoeringen van het programma, noch kan het afhangen van externe invoer van I / O-apparaten.
2. Evaluatie van het resultaat veroorzaakt geen semantisch waarneembare bijwerking of uitvoer, zoals mutatie van veranderlijke objecten of uitvoer naar I / O-apparaten

Als ontwikkelaar moet je je bewust zijn van pure methoden en zul je deze op veel gebieden tegenkomen. Een die ik heb gezien dat veel junior-ontwikkelaars bijt, werkt met DateTime-klassemethoden. Veel van deze zijn puur en als je je hier niet bewust van bent, kun je een verrassing krijgen. Een voorbeeld:

        DateTime sample = new DateTime(2016, 12, 25);
        sample.AddDays(1);
        Console.WriteLine(sample.ToShortDateString());

Gezien het bovenstaande voorbeeld kan men verwachten dat het resultaat dat op de console wordt afgedrukt '26 / 12/2016 'is, maar in werkelijkheid heb je dezelfde datum. Dit komt omdat AddDays een pure methode is en de oorspronkelijke datum niet beïnvloedt. Om de verwachte uitvoer te krijgen, moet u de AddDays-oproep als volgt wijzigen:

        sample = sample.AddDays(1);

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);
}

Ontleden en TryParse met cultuurinfo

Misschien wilt u het gebruiken bij het parseren van DateTimes uit verschillende culturen (talen) , in het volgende voorbeeld wordt Nederlandse datum ontleed.

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}

Voorbeeld van ontleden:

DateTime.Parse(dutchDateString, dutchCulture)
// output {31/10/1999 04:20:00}

DateTime als initializer 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());
}

Itereren op een TimeSpan werkt op dezelfde manier.

DateTime ToString, ToShortDateString, ToLongDateString en ToString opgemaakt

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
    }
}

Huidige datum

Om de huidige datum te krijgen, gebruikt u de eigenschap DateTime.Today . Dit retourneert een DateTime object met de datum van vandaag. Wanneer dit vervolgens wordt geconverteerd. .ToString() gebeurt dit standaard in de locatie van uw systeem.

Bijvoorbeeld:

Console.WriteLine(DateTime.Today);

Schrijft de datum van vandaag, in uw lokale indeling naar de console.

Datum en tijd vormen

Standaard datum / tijd-opmaak

DateTimeFormatInfo specificeert een set specifiers voor eenvoudige datum- en tijdnotatie. Elke specificator komt overeen met een bepaald opmaakpatroon van 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

Aangepaste datum / tijd-opmaak

Er zijn de volgende opmaakspecificaties:

• y (jaar)
• M (maand)
• d (dag)
• h (uur 12)
• H (uur 24)
• m (minuut)
• s (tweede)
• f (tweede fractie)
• F (tweede fractie, volgnullen worden bijgesneden)
• t (PM of AM)
• z (tijdzone).

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

U kunt ook datumscheidingsteken / (schuine streep) en tijdscheidingsteken : (dubbele punt) gebruiken.

Voor codevoorbeeld

Voor meer informatie MSDN .

DateTime.ParseExact (String, String, IFormatProvider)

Converteert de opgegeven stringvoorstelling van een datum en tijd naar zijn DateTime-equivalent met behulp van het opgegeven formaat en cultuurspecifieke formaatinformatie. Het formaat van de stringvoorstelling moet exact overeenkomen met het opgegeven formaat.

Converteer een specifieke notatiereeks naar een vergelijkbare DateTime

Laten we zeggen dat we een cultuurspecifieke DateTime-tekenreeks hebben 08-07-2016 11:30:12 PM als MM-dd-yyyy hh:mm:ss tt indeling en we willen dat deze wordt geconverteerd naar een equivalent DateTime object

string str = "08-07-2016 11:30:12 PM";
DateTime date = DateTime.ParseExact(str, "MM-dd-yyyy hh:mm:ss tt", CultureInfo.CurrentCulture);

Converteer een datumtijdstring naar een equivalent DateTime object zonder een specifieke cultuurindeling

Laten we zeggen dat we een DateTime-tekenreeks hebben in de indeling dd-MM-yy hh:mm:ss tt en we willen dat deze wordt geconverteerd naar een equivalent DateTime object, zonder specifieke cultuurinformatie

string str = "17-06-16 11:30:12 PM";
DateTime date = DateTime.ParseExact(str, "dd-MM-yy hh:mm:ss tt", CultureInfo.InvariantCulture);

Converteer een datumtijdstring naar een equivalent DateTime-object zonder een specifieke cultuurindeling met een andere indeling

Laten we zeggen dat we een datumreeks hebben, bijvoorbeeld '23 -12-2016 'of '12 / 23/2016' en we willen dat deze wordt geconverteerd naar een equivalent DateTime object, zonder specifieke cultuurinformatie

   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);

OPMERKING: System.Globalization moet worden toegevoegd voor CultureInfo Class

DateTime.TryParseExact (String, String, IFormatProvider, DateTimeStyles, DateTime)

Converteert de opgegeven tekenreeksrepresentatie van een datum en tijd naar zijn DateTime-equivalent met behulp van het opgegeven formaat, cultuurspecifieke formaatinformatie en stijl. Het formaat van de stringvoorstelling moet exact overeenkomen met het opgegeven formaat. De methode retourneert een waarde die aangeeft of de conversie is geslaagd.

Bijvoorbeeld

CultureInfo enUS = new CultureInfo("en-US");
string dateString;
System.DateTime dateValue;

Datum parseren zonder stijlvlaggen.

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);
}

Gebruik aangepaste formaten met M en 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);
}

Parseer een string met tijdzone-informatie.

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);
}

Parseer een string die UTC representeert.

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);
}

uitgangen

' 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).