Jak obciąć milisekundy dla daty .NET Data

Próbuję porównać znacznik czasu z przychodzącego żądania z wartością przechowywaną w bazie danych. SQL Server oczywiście zachowuje pewną precyzję w milisekundach czasu, a po wczytaniu do .NET DateTime uwzględnia te milisekundy. Przychodzące żądanie do systemu nie zapewnia jednak takiej precyzji, więc muszę po prostu upuścić milisekundy.

Czuję, że brakuje mi czegoś oczywistego, ale nie znalazłem eleganckiego sposobu na zrobienie tego (C #).

Poniższe będzie działać dla DateTime, który ma ułamkowe milisekundy, a także zachowuje właściwość Kind (lokalna, utc lub niezdefiniowana).

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

lub równoważny i krótszy:

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

Można to uogólnić na metodę rozszerzenia:

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

który jest używany w następujący sposób:

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

Oto metoda rozszerzenia oparta na poprzedniej odpowiedzi, która pozwala obciąć do dowolnej rozdzielczości ...

Stosowanie:

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

Klasa:

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

Czasami chcesz obciąć coś na podstawie kalendarza, na przykład rok lub miesiąc. Oto metoda rozszerzenia, która pozwala wybrać dowolną rozdzielczość.

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

Zamiast upuszczać milisekundy niż porównywać, dlaczego nie porównać różnicy?

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

lub

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

Mniej oczywiste, ale ponad 2 razy szybsze:

// 10000000 runs

DateTime d = DateTime.Now;

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

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

Aby zaokrąglić w dół do drugiej:

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

Zamień na, TicksPerMinuteaby zaokrąglić w dół do minuty.

Jeśli twój kod jest wrażliwy na wydajność, zachowaj ostrożność

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

Moja aplikacja spędzała 12% czasu procesora w System.DateTime.GetDatePart .

Sposobem na łatwe czytanie jest ...

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

I więcej...

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

Odnośnie odpowiedzi Diadistisa. To działało dla mnie, tyle że musiałem użyć Floor, aby usunąć ułamkową część podziału przed pomnożeniem. Więc,

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

staje się

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

Spodziewałbym się, że podział dwóch długich wartości da w wyniku Long, usuwając w ten sposób część dziesiętną, ale rozwiązuje to jako Double, pozostawiając dokładnie tę samą wartość po pomnożeniu.

Eppsja

2 Metody rozszerzenia wyżej wymienionych rozwiązań

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

stosowanie:

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

Nie najszybsze rozwiązanie, ale proste i łatwe do zrozumienia:

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 

I przy użyciu

ToLongDateString() // its show 19 February 2016.

: P

Nowa metoda

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

// zdefiniuj parametr Przekazanie ciągu dd-mmm-rrrr Zwróć 24-lut-2016

Lub pokazane na polu tekstowym

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

// włóż PageonLoad

W moim przypadku chciałem zaoszczędzić TimeSpan z narzędzia datetimePicker bez zapisywania sekund i milisekund, a oto rozwiązanie.

Najpierw przekonwertuj datetimePicker.value na żądany format, który to mój „HH: mm”, a następnie przekonwertuj go z powrotem na TimeSpan.

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

To jest moja wersja metod rozszerzenia opublikowanych tutaj i w podobnych pytaniach. Sprawdza to wartość tyknięć w łatwy do odczytania sposób i zachowuje DateTimeKind oryginalnej instancji DateTime. (Ma to subtelne, ale istotne skutki uboczne podczas przechowywania w bazie danych takiej jak MongoDB.)

Jeśli prawdziwym celem jest obcięcie DateTime do określonej wartości (tj. Godziny / Minuty / Sekundy / MS), zalecam zamiast tego wdrożenie tej metody rozszerzenia w kodzie. Zapewnia, że ​​można obciąć tylko z prawidłową precyzją i zachowuje ważne metadane DateTimeKind oryginalnej instancji:

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

Następnie możesz użyć następującej metody:

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

dateTime.Kind => DateTimeKind.Utc

Wiem, że odpowiedź jest dość późna, ale najlepszym sposobem na pozbycie się milisekund jest

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

Spróbuj wydrukować wartość zmiennej, pokaże datę i godzinę, bez milisekund.