Comment comparer uniquement les composants de date de DateTime dans EF?

J'ai deux valeurs de date, l'une déjà stockée dans la base de données et l'autre sélectionnée par l'utilisateur à l'aide de DatePicker. Le cas d'utilisation est de rechercher une date particulière dans la base de données.

La valeur précédemment entrée dans la base de données a toujours une composante d'heure de 12:00:00, alors que la date entrée à partir du sélecteur a une composante d'heure différente.

Je ne suis intéressé que par les composants de date et je voudrais ignorer le composant de temps.

Quelles sont les façons de faire cette comparaison en C #?

Aussi, comment faire cela dans LINQ?

MISE À JOUR: sur LINQ to Entities, ce qui suit fonctionne correctement.

e => DateTime.Compare(e.FirstDate.Value, SecondDate) >= 0

REMARQUE: au moment de la rédaction de cette réponse, la relation EF n'était pas claire (qui a été modifiée dans la question après avoir été écrite). Pour une approche correcte avec EF, vérifiez la réponse de Mandeeps .

Vous pouvez utiliser la DateTime.Datepropriété pour effectuer une comparaison de date uniquement.

DateTime a = GetFirstDate();
DateTime b = GetSecondDate();

if (a.Date.Equals(b.Date))
{
    // the dates are equal
}

Utilisez la classe EntityFunctionspour découper la partie temporelle.

using System.Data.Objects;    

var bla = (from log in context.Contacts
           where EntityFunctions.TruncateTime(log.ModifiedDate) ==  EntityFunctions.TruncateTime(today.Date)
           select log).FirstOrDefault();

Source: http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/84d4e18b-7545-419b-9826-53ff1a0e2a62/

METTRE À JOUR

À partir d'EF 6.0 et versions ultérieures, EntityFunctions est remplacé par DbFunctions .

Je pense que cela pourrait vous aider.

J'ai fait une extension car je dois comparer les dates dans des référentiels remplis de données EF et donc .Date n'était pas une option car il n'est pas implémenté dans la traduction LinqToEntities.

Voici le code:

        /// <summary>
    /// Check if two dates are same
    /// </summary>
    /// <typeparam name="TElement">Type</typeparam>
    /// <param name="valueSelector">date field</param>
    /// <param name="value">date compared</param>
    /// <returns>bool</returns>
    public Expression<Func<TElement, bool>> IsSameDate<TElement>(Expression<Func<TElement, DateTime>> valueSelector, DateTime value)
    {
        ParameterExpression p = valueSelector.Parameters.Single();

        var antes = Expression.GreaterThanOrEqual(valueSelector.Body, Expression.Constant(value.Date, typeof(DateTime)));

        var despues = Expression.LessThan(valueSelector.Body, Expression.Constant(value.AddDays(1).Date, typeof(DateTime)));

        Expression body = Expression.And(antes, despues);

        return Expression.Lambda<Func<TElement, bool>>(body, p);
    }

alors vous pouvez l'utiliser de cette manière.

 var today = DateTime.Now;
 var todayPosts = from t in turnos.Where(IsSameDate<Turno>(t => t.MyDate, today))
                                      select t);

Si vous utilisez la Datepropriété pour les entités DB, vous obtiendrez une exception:

"The specified type member 'Date' is not supported in LINQ to Entities. Only initializers, entity members, and entity navigation properties are supported."

Vous pouvez utiliser quelque chose comme ceci:

  DateTime date = DateTime.Now.Date;

  var result = from client in context.clients
               where client.BirthDate >= date
                     && client.BirthDate < date.AddDays(1)
               select client;

Pour le faire dans LINQ to Entities, vous devez utiliser les méthodes prises en charge :

var year = someDate.Year;
var month = ...
var q = from r in Context.Records
        where Microsoft.VisualBasic.DateAndTime.Year(r.SomeDate) == year 
              && // month and day

Moche, mais ça marche, et c'est fait sur le serveur DB.

Voici une manière différente de le faire, mais ce n'est utile que si SecondDate est une variable que vous passez:

DateTime startDate = SecondDate.Date;
DateTime endDate = startDate.AddDays(1).AddTicks(-1);
...
e => e.FirstDate.Value >= startDate && e.FirstDate.Value <= endDate

Je pense que ça devrait marcher

Vous pouvez également utiliser ceci:

DbFunctions.DiffDays(date1, date2) == 0

vous pouvez utiliser la méthode DbFunctions.TruncateTime () pour cela.

e => DbFunctions.TruncateTime(e.FirstDate.Value) == DbFunctions.TruncateTime(SecondDate);

Comparez toujours la propriété Date de DateTime, au lieu de la date complète.

Lorsque vous effectuez votre requête LINQ, utilisez date.Date dans la requête, c'est-à-dire:

var results = from c in collection
              where c.Date == myDateTime.Date
              select c;

C'est comme ça que je fais ça.

DateTime date_time_to_compare = DateTime.Now;
//Compare only date parts
context.YourObject.FirstOrDefault(r =>
                EntityFunctions.TruncateTime(r.date) == EntityFunctions.TruncateTime(date_to_compare));

// Remarque pour les utilisateurs / codeurs Linq

Cela devrait vous donner la comparaison exacte pour vérifier si une date tombe dans la plage lorsque vous travaillez avec l'entrée d'un utilisateur - sélecteur de date par exemple:

((DateTime)ri.RequestX.DateSatisfied).Date >= startdate.Date &&
        ((DateTime)ri.RequestX.DateSatisfied).Date <= enddate.Date

où startdate et enddate sont des valeurs d'un sélecteur de date.

Sans le temps, essayez comme ceci:

TimeSpan ts = new TimeSpan(23, 59, 59);
toDate = toDate.Add(ts);
List<AuditLog> resultLogs = 
    _dbContext.AuditLogs
    .Where(al => al.Log_Date >= fromDate && al.Log_Date <= toDate)
    .ToList();
return resultLogs;

Vous pouvez utiliser le lien ci-dessous pour comparer 2 dates sans heure:

private bool DateGreaterOrEqual(DateTime dt1, DateTime dt2)
        {
            return DateTime.Compare(dt1.Date, dt2.Date) >= 0;
        }

private bool DateLessOrEqual(DateTime dt1, DateTime dt2)
        {
            return DateTime.Compare(dt1.Date, dt2.Date) <= 0;
        }

la fonction Compare renvoie 3 valeurs différentes: -1 0 1 ce qui signifie dt1> dt2, dt1 = dt2, dt1

Essayez ceci ... Cela fonctionne bien pour comparer les propriétés Date entre deux types DateTimes:

PS. C'est une solution provisoire et une très mauvaise pratique, ne doit jamais être utilisée quand on sait que la base de données peut apporter des milliers d'enregistrements ...

query = query.ToList()
             .Where(x => x.FirstDate.Date == SecondDate.Date)
             .AsQueryable();