Come troncare millisecondi di un DateTime .NET

Sto cercando di confrontare un timestamp da una richiesta in arrivo con un valore memorizzato nel database. SQL Server ovviamente mantiene una precisione di millisecondi nel tempo e, quando viene letto in un DateTime .NET, include quei millisecondi. La richiesta in arrivo al sistema, tuttavia, non offre quella precisione, quindi devo semplicemente eliminare i millisecondi.

Sento che mi manca qualcosa di ovvio, ma non ho trovato un modo elegante per farlo (C #).

Di seguito funzionerà per un DateTime che ha millisecondi frazionari e conserva anche la proprietà Kind (Local, Utc o Undefined).

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

o l'equivalente e più breve:

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

Questo potrebbe essere generalizzato in un metodo di estensione:

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

che viene utilizzato come segue:

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

Ecco un metodo di estensione basato su una risposta precedente che ti permetterà di troncare a qualsiasi risoluzione ...

Uso:

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

Classe:

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

A volte vuoi troncare a qualcosa di basato sul calendario, come l'anno o il mese. Ecco un metodo di estensione che ti consente di scegliere qualsiasi risoluzione.

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

Invece di perdere i millisecondi e confrontarli, perché non confrontare la differenza?

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

o

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

Meno ovvio ma più di 2 volte più veloce:

// 10000000 runs

DateTime d = DateTime.Now;

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

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

Per arrotondare al secondo:

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

Sostituire con TicksPerMinuteper arrotondare al minuto.

Se il tuo codice è sensibile alle prestazioni, fai attenzione

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

La mia app impiegava il 12% del tempo della CPU in System.DateTime.GetDatePart .

Un modo per leggere facilmente è ...

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

E altro ...

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

Per quanto riguarda la risposta di Diadistis. Questo ha funzionato per me, tranne per il fatto che ho dovuto usare Floor per rimuovere la parte frazionaria della divisione prima della moltiplicazione. Così,

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

diventa

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

Mi sarei aspettato che la divisione di due valori Long risultasse in Long, rimuovendo così la parte decimale, ma la risolve come Double lasciando lo stesso valore esatto dopo la moltiplicazione.

Eppsy

2 Metodi di estensione per le soluzioni sopra menzionate

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

utilizzo:

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

Non la soluzione più veloce ma semplice e di facile comprensione:

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 

E per uso di

ToLongDateString() // its show 19 February 2016.

: P

Nuovo metodo

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

// definisce il parametro String pass dd-mmm-yyyy return 24-feb-2016

O mostrato nella casella di testo

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

// metti su PageonLoad

Nel mio caso, miravo a salvare TimeSpan dallo strumento datetimePicker senza salvare i secondi e i millisecondi, ed ecco la soluzione.

Per prima cosa converti datetimePicker.value nel formato desiderato, il mio è "HH: mm", quindi riconvertilo in TimeSpan.

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

Questa è la mia versione dei metodi di estensione pubblicati qui e in domande simili. Ciò convalida il valore di tick in un modo facile da leggere e conserva DateTimeKind dell'istanza DateTime originale. (Ciò ha effetti collaterali sottili ma rilevanti quando si archivia in un database come MongoDB.)

Se il vero obiettivo è troncare un DateTime su un valore specificato (ad es. Ore / Minuti / Secondi / MS), consiglio invece di implementare questo metodo di estensione nel codice. Assicura che puoi troncare solo con una precisione valida e conserva gli importanti metadati DateTimeKind della tua istanza originale:

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

Quindi è possibile utilizzare il metodo in questo modo:

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

dateTime.Kind => DateTimeKind.Utc

So che la risposta è abbastanza tardi, ma il modo migliore per sbarazzarsi di millisecondi è

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

Prova a stampare il valore della variabile, mostrerà la data e l'ora, senza millisecondi.