So schneiden Sie Millisekunden von einer .NET DateTime ab

Ich versuche, einen Zeitstempel von einer eingehenden Anforderung mit einem in der Datenbank gespeicherten Wert zu vergleichen. SQL Server behält natürlich eine gewisse Genauigkeit von Millisekunden bei, und wenn es in eine .NET DateTime eingelesen wird, enthält es diese Millisekunden. Die eingehende Anforderung an das System bietet jedoch nicht diese Genauigkeit, sodass ich einfach die Millisekunden löschen muss.

Ich habe das Gefühl, dass mir etwas Offensichtliches fehlt, aber ich habe keinen eleganten Weg gefunden, dies zu tun (C #).

Das Folgende funktioniert für eine DateTime mit Millisekundenbruchteilen und behält auch die Kind-Eigenschaft (Local, Utc oder Undefined) bei.

DateTime dateTime = ... anything ...
dateTime = new DateTime(
    dateTime.Ticks - (dateTime.Ticks % TimeSpan.TicksPerSecond), 
    dateTime.Kind
    );

oder das Äquivalent und kürzer:

dateTime = dateTime.AddTicks( - (dateTime.Ticks % TimeSpan.TicksPerSecond));

Dies könnte in eine Erweiterungsmethode verallgemeinert werden:

public static DateTime Truncate(this DateTime dateTime, TimeSpan timeSpan)
{
    if (timeSpan == TimeSpan.Zero) return dateTime; // Or could throw an ArgumentException
    if (dateTime == DateTime.MinValue || dateTime == DateTime.MaxValue) return dateTime; // do not modify "guard" values
    return dateTime.AddTicks(-(dateTime.Ticks % timeSpan.Ticks));
}

welches wie folgt verwendet wird:

dateTime = dateTime.Truncate(TimeSpan.FromMilliseconds(1)); // Truncate to whole ms
dateTime = dateTime.Truncate(TimeSpan.FromSeconds(1)); // Truncate to whole second
dateTime = dateTime.Truncate(TimeSpan.FromMinutes(1)); // Truncate to whole minute
...

var date = DateTime.Now;

date = new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);

Hier ist eine Erweiterungsmethode, die auf einer vorherigen Antwort basiert und es Ihnen ermöglicht, auf eine beliebige Auflösung zu kürzen ...

Verwendungszweck:

DateTime myDateSansMilliseconds = myDate.Truncate(TimeSpan.TicksPerSecond);
DateTime myDateSansSeconds = myDate.Truncate(TimeSpan.TicksPerMinute)

Klasse:

public static class DateTimeUtils
{
    /// <summary>
    /// <para>Truncates a DateTime to a specified resolution.</para>
    /// <para>A convenient source for resolution is TimeSpan.TicksPerXXXX constants.</para>
    /// </summary>
    /// <param name="date">The DateTime object to truncate</param>
    /// <param name="resolution">e.g. to round to nearest second, TimeSpan.TicksPerSecond</param>
    /// <returns>Truncated DateTime</returns>
    public static DateTime Truncate(this DateTime date, long resolution)
    {
        return new DateTime(date.Ticks - (date.Ticks % resolution), date.Kind);
    }
}

DateTime d = DateTime.Now;
d = d.AddMilliseconds(-d.Millisecond);

Manchmal möchten Sie auf etwas Kalenderbasiertes wie Jahr oder Monat kürzen. Hier ist eine Erweiterungsmethode, mit der Sie eine beliebige Auflösung auswählen können.

public enum DateTimeResolution
{
    Year, Month, Day, Hour, Minute, Second, Millisecond, Tick
}

public static DateTime Truncate(this DateTime self, DateTimeResolution resolution = DateTimeResolution.Second)
{
    switch (resolution)
    {
        case DateTimeResolution.Year:
            return new DateTime(self.Year, 1, 1, 0, 0, 0, 0, self.Kind);
        case DateTimeResolution.Month:
            return new DateTime(self.Year, self.Month, 1, 0, 0, 0, self.Kind);
        case DateTimeResolution.Day:
            return new DateTime(self.Year, self.Month, self.Day, 0, 0, 0, self.Kind);
        case DateTimeResolution.Hour:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerHour));
        case DateTimeResolution.Minute:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerMinute));
        case DateTimeResolution.Second:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerSecond));
        case DateTimeResolution.Millisecond:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerMillisecond));
        case DateTimeResolution.Tick:
            return self.AddTicks(0);
        default:
            throw new ArgumentException("unrecognized resolution", "resolution");
    }
}

Warum nicht den Unterschied vergleichen, anstatt die Millisekunden fallen zu lassen und dann zu vergleichen?

DateTime x; DateTime y;
bool areEqual = (x-y).TotalSeconds == 0;

oder

TimeSpan precision = TimeSpan.FromSeconds(1);
bool areEqual = (x-y).Duration() < precision;

Weniger offensichtlich, aber mehr als zweimal schneller:

// 10000000 runs

DateTime d = DateTime.Now;

// 484,375ms
d = new DateTime((d.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);

// 1296,875ms
d = d.AddMilliseconds(-d.Millisecond);

Um auf die Sekunde abzurunden:

dateTime.AddTicks(-dateTime.Ticks % TimeSpan.TicksPerSecond)

Ersetzen Sie durch TicksPerMinute, um auf die Minute abzurunden.

Wenn Ihr Code leistungsabhängig ist, seien Sie vorsichtig

new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second)

Meine App verbrachte 12% der CPU-Zeit in System.DateTime.GetDatePart .

Ein Weg zum einfachen Lesen ist ...

//Remove milliseconds
DateTime date = DateTime.Now;
date = DateTime.ParseExact(date.ToString("yyyy-MM-dd HH:mm:ss"), "yyyy-MM-dd HH:mm:ss", null);

Und mehr...

//Remove seconds
DateTime date = DateTime.Now;
date = DateTime.ParseExact(date.ToString("yyyy-MM-dd HH:mm"), "yyyy-MM-dd HH:mm", null);

//Remove minutes
DateTime date = DateTime.Now;
date = DateTime.ParseExact(date.ToString("yyyy-MM-dd HH"), "yyyy-MM-dd HH", null);

//and go on...

In Bezug auf Diadistis Antwort. Dies funktionierte für mich, außer dass ich Floor verwenden musste, um den Bruchteil der Division vor der Multiplikation zu entfernen. Damit,

d = new DateTime((d.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);

wird

d = new DateTime(Math.Floor(d.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);

Ich hätte erwartet, dass die Division von zwei Long-Werten zu einem Long führt, wodurch der Dezimalteil entfernt wird, aber es wird als Double aufgelöst, wobei nach der Multiplikation genau derselbe Wert erhalten bleibt.

Eppsy

2 Erweiterungsmethoden für die oben genannten Lösungen

    public static bool LiesAfterIgnoringMilliseconds(this DateTime theDate, DateTime compareDate, DateTimeKind kind)
    {
        DateTime thisDate = new DateTime(theDate.Year, theDate.Month, theDate.Day, theDate.Hour, theDate.Minute, theDate.Second, kind);
        compareDate = new DateTime(compareDate.Year, compareDate.Month, compareDate.Day, compareDate.Hour, compareDate.Minute, compareDate.Second, kind);

        return thisDate > compareDate;
    }


    public static bool LiesAfterOrEqualsIgnoringMilliseconds(this DateTime theDate, DateTime compareDate, DateTimeKind kind)
    {
        DateTime thisDate = new DateTime(theDate.Year, theDate.Month, theDate.Day, theDate.Hour, theDate.Minute, theDate.Second, kind);
        compareDate = new DateTime(compareDate.Year, compareDate.Month, compareDate.Day, compareDate.Hour, compareDate.Minute, compareDate.Second, kind);

        return thisDate >= compareDate;
    }

Verwendungszweck:

bool liesAfter = myObject.DateProperty.LiesAfterOrEqualsIgnoringMilliseconds(startDateTime, DateTimeKind.Utc);

Nicht die schnellste Lösung, aber einfach und leicht zu verstehen:

DateTime d = DateTime.Now;
d = d.Date.AddHours(d.Hour).AddMinutes(d.Minute).AddSeconds(d.Second)

DateID.Text = DateTime.Today.ToShortDateString();

Use ToShortDateString() //Date 2-02-2016
Use ToShortDateString() // Time 

Und durch Verwendung von

ToLongDateString() // its show 19 February 2016.

: P.

Neue Methode

String Date = DateTime.Today.ToString("dd-MMM-yyyy"); 

// String-Pass-Parameter definieren TT-MMM-JJJJ Rückgabe 24.02.2016

Oder im Textfeld angezeigt

txtDate.Text = DateTime.Today.ToString("dd-MMM-yyyy");

// PageonLoad aufsetzen

In meinem Fall wollte ich TimeSpan aus dem datetimePicker-Tool speichern, ohne die Sekunden und Millisekunden zu speichern. Hier ist die Lösung.

Konvertieren Sie zuerst den datetimePicker.value in das gewünschte Format. Meines ist "HH: mm" und konvertieren Sie ihn dann zurück in TimeSpan.

var datetime = datetimepicker1.Value.ToString("HH:mm");
TimeSpan timeSpan = Convert.ToDateTime(datetime).TimeOfDay;

Dies ist meine Version der hier und in ähnlichen Fragen veröffentlichten Erweiterungsmethoden. Dadurch wird der Ticks-Wert auf leicht lesbare Weise überprüft und das DateTimeKind der ursprünglichen DateTime-Instanz beibehalten. (Dies hat subtile, aber relevante Nebenwirkungen beim Speichern in einer Datenbank wie MongoDB.)

Wenn das eigentliche Ziel darin besteht, eine DateTime auf einen bestimmten Wert (dh Stunden / Minuten / Sekunden / MS) zu kürzen, empfehle ich, diese Erweiterungsmethode stattdessen in Ihrem Code zu implementieren. Es stellt sicher, dass Sie nur mit einer gültigen Genauigkeit abschneiden können, und behält die wichtigen DateTimeKind-Metadaten Ihrer ursprünglichen Instanz bei:

public static DateTime Truncate(this DateTime dateTime, long ticks)
{
    bool isValid = ticks == TimeSpan.TicksPerDay 
        || ticks == TimeSpan.TicksPerHour 
        || ticks == TimeSpan.TicksPerMinute 
        || ticks == TimeSpan.TicksPerSecond 
        || ticks == TimeSpan.TicksPerMillisecond;

    // /programming/21704604/have-datetime-now-return-to-the-nearest-second
    return isValid 
        ? DateTime.SpecifyKind(
            new DateTime(
                dateTime.Ticks - (dateTime.Ticks % ticks)
            ),
            dateTime.Kind
        )
        : throw new ArgumentException("Invalid ticks value given. Only TimeSpan tick values are allowed.");
}

Dann können Sie die Methode wie folgt verwenden:

DateTime dateTime = DateTime.UtcNow.Truncate(TimeSpan.TicksPerMillisecond);

dateTime.Kind => DateTimeKind.Utc

Ich weiß, dass die Antwort ziemlich spät ist, aber der beste Weg, Millisekunden loszuwerden, ist

var currentDateTime = DateTime.Now.ToString("s");

Versuchen Sie, den Wert der Variablen zu drucken. Es wird die Datums- und Uhrzeit ohne Millisekunden angezeigt.