Comment tronquer les millisecondes hors d'un .NET DateTime

J'essaie de comparer un horodatage d'une demande entrante à une valeur stockée de base de données. SQL Server conserve bien sûr une certaine précision de millisecondes sur l'heure, et lorsqu'il est lu dans un .NET DateTime, il inclut ces millisecondes. La demande entrante au système, cependant, n'offre pas cette précision, donc je dois simplement laisser tomber les millisecondes.

J'ai l'impression de manquer quelque chose d'évident, mais je n'ai pas trouvé de façon élégante de le faire (C #).

Ce qui suit fonctionnera pour un DateTime qui a des millisecondes fractionnaires et conserve également la propriété Kind (Local, Utc ou Undefined).

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

ou l'équivalent et plus court:

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

Cela pourrait être généralisé dans une méthode d'extension:

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

qui est utilisé comme suit:

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

Voici une méthode d'extension basée sur une réponse précédente qui vous permettra de tronquer à n'importe quelle résolution ...

Usage:

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

Parfois, vous souhaitez tronquer quelque chose en fonction du calendrier, comme l'année ou le mois. Voici une méthode d'extension qui vous permet de choisir n'importe quelle résolution.

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

Au lieu de laisser tomber les millisecondes puis de comparer, pourquoi ne pas comparer la différence?

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

ou

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

Moins évident mais plus de 2 fois plus rapide:

// 10000000 runs

DateTime d = DateTime.Now;

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

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

Pour arrondir à la seconde:

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

Remplacez par TicksPerMinutepour arrondir à la minute près.

Si votre code est sensible aux performances, soyez prudent

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

Mon application passait 12% du temps CPU dans System.DateTime.GetDatePart .

Un moyen de lecture facile est ...

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

Et plus...

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

Concernant la réponse de Diadistis. Cela a fonctionné pour moi, sauf que j'ai dû utiliser Floor pour supprimer la partie fractionnaire de la division avant la multiplication. Alors,

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

devient

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

Je m'attendais à ce que la division de deux valeurs Long aboutisse à un Long, supprimant ainsi la partie décimale, mais elle la résout comme un Double, laissant la même valeur exacte après la multiplication.

Eppsy

2 Méthodes d'extension pour les solutions mentionnées ci-dessus

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

usage:

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

Pas la solution la plus rapide mais simple et facile à comprendre:

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 

Et par l'utilisation de

ToLongDateString() // its show 19 February 2016.

: P

Nouvelle méthode

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

// définir le paramètre de passe de chaîne jj-mmm-aaaa return 24-feb-2016

Ou affiché sur la zone de texte

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

// mettre sur PageonLoad

Dans mon cas, je visais à sauver TimeSpan de l'outil datetimePicker sans enregistrer les secondes et les millisecondes, et voici la solution.

Convertissez d'abord le datetimePicker.value au format de votre choix, le mien est "HH: mm", puis reconvertissez-le en TimeSpan.

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

Ceci est ma version des méthodes d'extension publiées ici et dans des questions similaires. Cela valide la valeur des graduations d'une manière facile à lire et préserve le DateTimeKind de l'instance DateTime d'origine. (Cela a des effets secondaires subtils mais pertinents lors du stockage dans une base de données comme MongoDB.)

Si le véritable objectif est de tronquer un DateTime à une valeur spécifiée (c'est-à-dire Heures / Minutes / Secondes / MS), je recommande plutôt d'implémenter cette méthode d'extension dans votre code. Il garantit que vous ne pouvez tronquer qu'avec une précision valide et il conserve les métadonnées DateTimeKind importantes de votre instance d'origine:

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

Ensuite, vous pouvez utiliser la méthode comme ceci:

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

dateTime.Kind => DateTimeKind.Utc

Je sais que la réponse est assez tardive, mais la meilleure façon de se débarrasser des millisecondes est

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

Essayez d'imprimer la valeur de la variable, elle affichera la date et l'heure, sans millisecondes.