Cómo truncar milisegundos de un .NET DateTime

Estoy tratando de comparar una marca de tiempo de una solicitud entrante a un valor almacenado de la base de datos. SQL Server, por supuesto, mantiene cierta precisión de milisegundos en el tiempo, y cuando se lee en un .NET DateTime, incluye esos milisegundos. Sin embargo, la solicitud entrante al sistema no ofrece esa precisión, por lo que simplemente necesito soltar los milisegundos.

Siento que me falta algo obvio, pero no he encontrado una manera elegante de hacerlo (C #).

Lo siguiente funcionará para un DateTime que tiene milisegundos fraccionales y también conserva la propiedad Kind (Local, Utc o Undefined).

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

o el equivalente y más corto:

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

Esto podría generalizarse en un método de extensión:

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

que se usa de la siguiente manera:

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

Aquí hay un método de extensión basado en una respuesta anterior que le permitirá truncar a cualquier resolución ...

Uso:

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

Clase:

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 veces desea truncar a algo basado en el calendario, como año o mes. Aquí hay un método de extensión que le permite elegir cualquier resolución.

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

En lugar de soltar los milisegundos y luego comparar, ¿por qué no comparar la diferencia?

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

o

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

Menos obvio pero más de 2 veces más rápido:

// 10000000 runs

DateTime d = DateTime.Now;

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

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

Para redondear a la segunda:

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

Reemplace con TicksPerMinutepara redondear al minuto.

Si su código es sensible al rendimiento, tenga cuidado con

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

Mi aplicación estaba gastando el 12% del tiempo de CPU en System.DateTime.GetDatePart .

Una forma de lectura fácil es ...

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

Y más...

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

Respecto a la respuesta de Diadistis. Esto funcionó para mí, excepto que tuve que usar Floor para eliminar la parte fraccional de la división antes de la multiplicación. Entonces,

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

se convierte

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

Hubiera esperado que la división de dos valores Long produjera un Long, eliminando así la parte decimal, pero lo resuelve como un Doble dejando exactamente el mismo valor después de la multiplicación.

Eppsia

2 Métodos de extensión para las soluciones mencionadas anteriormente

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

uso:

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

No es la solución más rápida pero simple y fácil de entender:

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 

Y por uso de

ToLongDateString() // its show 19 February 2016.

:PAGS

Nuevo método

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

// define el parámetro de paso de cadena dd-mmm-aaaa retorno 24-feb-2016

O se muestra en el cuadro de texto

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

// poner PageonLoad

En mi caso, tenía el objetivo de salvar TimeSpan de la herramienta datetimePicker sin guardar los segundos y los milisegundos, y aquí está la solución.

Primero convierta el datetimePicker.value a su formato deseado, el mío es "HH: mm" y luego vuelva a convertirlo a TimeSpan.

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

Esta es mi versión de los métodos de extensión publicados aquí y en preguntas similares. Esto valida el valor de los ticks de una manera fácil de leer y conserva el DateTimeKind de la instancia original de DateTime. (Esto tiene efectos secundarios sutiles pero relevantes cuando se almacena en una base de datos como MongoDB).

Si el verdadero objetivo es truncar un DateTime a un valor específico (es decir, horas / minutos / segundos / MS), recomiendo implementar este método de extensión en su código. Asegura que solo puede truncar con una precisión válida y conserva los metadatos importantes DateTimeKind de su instancia original:

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

Entonces puedes usar el método de esta manera:

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

dateTime.Kind => DateTimeKind.Utc

Sé que la respuesta es bastante tardía, pero la mejor manera de deshacerse de milisegundos es

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

Intente imprimir el valor de la variable, mostrará la fecha y hora, sin milisegundos.