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

Je vais avoir deux valeurs de date, on a déjà stockées dans la base de données et l'autre choisi par l'utilisateur à l'aide de DatePicker. Le cas d'utilisation est à la recherche d'une date donnée à partir de la base de données.

La valeur précédemment saisie dans la base de données a toujours le temps de composante à 12:00:00, où, à la date de saisie de sélecteur a différents temps de la composante.

Je suis uniquement intéressé par les composants de date et souhaitez ignorer la composante temporelle.

Quels sont les moyens de faire cette comparaison en C#?

Aussi, la façon de faire dans LINQ?

Mise à JOUR:
Sur LINQ to entities, le suivant fonctionne très bien.

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

Vous pouvez également jeter un oeil à cette DONC, la question: stackoverflow.com/questions/683037/how-to-compare-dates-in-c/...

InformationsquelleAutor pencilslate | 2009-09-25

c#datetime-comparison entity-framework linq linq-to-entities

120

REMARQUE: au moment de la rédaction de cette réponse, l'EF-relation n'était pas claire (qui a été édité dans la question après ce qui était écrit). Pour une bonne approche avec les objectifs EF, vérifiez Mandeeps répondre.

Vous pouvez utiliser le DateTime.Date propriété pour procéder à une date seule comparaison.
```
DateTime a = GetFirstDate();
DateTime b = GetSecondDate();

if (a.Date.Equals(b.Date))
{
    //the dates are equal
}
```
- Il est facile de comparer la date, mais la question est liée à LINQ to entities qui est incapable de convertir .Propriété de Date en SQL.
- bon point. Apparemment il encore résolu le cas des OP problème.
- Ce n'est pas de requête de la base de données, mais plutôt des processus les données dans le CLR / de l'application de la couche après le fait. La vraie solution est d'utiliser le EntityFunctions.TruncateTime(..) fonctionnent comme spécifié dans la réponse ci-dessous, car il envoie la requête à la base de données et permet le traitement à faire à la couche de stockage. Sans cela, vous ne pouviez pas utiliser la date de comparaison de logique Où / Compter les clauses et puis encore une question sur les données filtrées, depuis que vous auriez à tirer des résultats partiels dans la couche d'application, d'abord, qui peut être un deal-breaker dans les scénarios que les processus de grandes masses de données.
- Oui, EntityFunctions.TruncateTime certainement semblent être la voie à suivre ces jours-ci (il est devenu disponible .NET 4, qui a été publié l'année d'après, cette question a été posée).
- l'utilisation du Système.Les données.De l'entité.DbFunctions.TruncateTime() la méthode. Vous devez ajouter une référence à EntityFramework
InformationsquelleAutor Fredrik Mörk
130

Utiliser la classe EntityFunctions pour la coupe du temps de la partie.
```
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/

Mise à JOUR

Que de l'EF 6.0 et versions ultérieures EntityFunctions est remplacé par DbFunctions.
- Juste une remarque EntityFunctions a été dépréciée en faveur de System.Data.Entity.DbFunctions pour (au moins) EF6. Il peut avoir été plus tôt que cela.
- Je ne voudrais pas être rapide pour passer à cette solution car elle est vraiment lent, plus d'infos: stackoverflow.com/questions/22776843/...
- Cela ne fonctionne pas quand elle est soutenue par MySql?
- Ne semble pas fonctionner avec une base de données SQLite. J'ai "SQL erreur de logique ou de base de données manquant pas une telle fonction: TruncateTime".
InformationsquelleAutor Mandeep Janjua

Je pense que cela pourrait vous aider.

J'ai fait une extension depuis que je suis à comparer des dates dans des dépôts rempli avec EF données et ainsi de .La Date n'était pas une option, car elle n'est pas implémentée dans LinqToEntities traduction.

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 façon.

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

InformationsquelleAutor

Si vous utilisez le Date propriété de DB Entités, vous obtiendrez 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;

InformationsquelleAutor algreat

De le faire dans LINQ to entities, vous devez utiliser 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 fonctionne, et c'est fait sur le serveur de base de données.

InformationsquelleAutor Craig Stuntz

8

Voici une autre façon de le faire, mais il est seulement utile si SecondDate est une variable que vous êtes de passage dans:
```
DateTime startDate = SecondDate.Date;
DateTime endDate = startDate.AddDays(1).AddTicks(-1);
...
e => e.FirstDate.Value >= startDate && e.FirstDate.Value <= endDate
```
Je pense que cela devrait fonctionner
- Excellent. A travaillé pour moi. C'était l'explicite DateTime = x.Date; j'ai été absent. Si j'ai utilisé var, ou qui avaient de la valeur inline dans la comparaison, il a échoué à l'exception signalée. Merci.
- Heureux, il a travaillé, Tim. Désolé pour le retard dans la réponse - je n'ai pas vraiment entré dans le faire dans un certain temps.
- Si vous modifiez e.FirstDate.Value <= endDate à e.FirstDate.Value < endDate vous pouvez supprimer le .AddTicks(-1).
- vous avez raison, ce serait certainement le travail aussi bien. L'expression conditionnelle illustré est destiné aux inclusive comparaisons de date exacte de début et de fin datetimes (en supposant que la date de plage de valeurs serait passé à l'état plutôt que dans un fragment de code.) OIE, la condition est considérée comme distincte de l'valeurs datetime.
InformationsquelleAutor John Kaster
6

Vous pouvez également utiliser cette:

DbFunctions.DiffDays(date1, date2) == 0

InformationsquelleAutor user3829854
4

vous pouvez utiliser DbFunctions.TruncateTime() méthode pour cela.
```
e => DbFunctions.TruncateTime(e.FirstDate.Value) == DbFunctions.TruncateTime(SecondDate);
```
InformationsquelleAutor Harsh Vyas
3

Juste de toujours comparer les Date propriété de DateTime, au lieu de la date de temps.

Lorsque vous effectuez votre requête LINQ, l'utilisation de la date.Date de la requête, c'est à dire:
```
var results = from c in collection
              where c.Date == myDateTime.Date
              select c;
```
- J'obtiens l'erreur "Le type spécifié membre 'Date' n'est pas pris en charge dans LINQ to entities. Seulement les initialiseurs, les membres de l'entité et l'entité propriétés de navigation sont pris en charge.". Toutes les pensées?
- Oui - votre fournisseur n'est pas la poignée de la .Date de la propriété directement. Vous aurez à retirer, et de comparer les dates plus tard.
- .La Date ne peut pas être utilisé dans Linq to entities, malheureusement. Espérons que MS va ajouter que la surcharge de soutien à bientôt
- Toujours comparer la Date de la propriété? J'ai googlé dans ce commentaire, car je me suis demandé si c'est la meilleure pratique, c'est à dire. pour toujours utilisation de la Date de la propriété, même quand c'est quelque chose comme candidate.Date >= base.Date. En principe, le candidate.Date temps doit être >= 12:00:00, donc, en utilisant la propriété de Date est redondant, mais je vais rester avec Reed conseils.
InformationsquelleAutor Reed Copsey

C'est la façon dont je le fais.

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

InformationsquelleAutor Alejandro del Río

2

Juste si quelqu'un arrive ici googler ou binging... compilé des solutions de contournement:

http://blog.integratedsolution.eu/post/2011/02/06/The-specified-type-member-Date-is-not-supported-in-LINQ-to-Entities.aspx
- Le lien est mort.
InformationsquelleAutor Braulio
2

//Note de Linq Utilisateurs/Programmeurs

Cela devrait vous donner la comparaison exacte pour vérifier si une date se situe dans la plage lorsque l'on travaille avec la participation de l'utilisateur sélecteur de date par exemple:
```
((DateTime)ri.RequestX.DateSatisfied).Date >= startdate.Date &&
        ((DateTime)ri.RequestX.DateSatisfied).Date <= enddate.Date
```
startdate et enddate sont des valeurs à partir d'un sélecteur de date.

InformationsquelleAutor Leo Di Salty

Sans de temps que d'essayer 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;

InformationsquelleAutor Nalan Madheswaran

Vous pouvez l'utilisateur ci-dessous le lien pour comparer 2 dates, sans temps :

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

de la fonction de comparaison de retour de 3 valeurs différentes: -1 0 1, ce qui signifie dt1>dt2, dt1=dt2, dt1

Pourquoi ne pas vous juste retour DateTime.Comparer(dt1.Date, dt2.La Date)? Cela rend d'autant que vous avez besoin.

InformationsquelleAutor majid

0

Essayez ceci... Il fonctionne très bien pour comparer les propriétés de Date entre les deux DateTimes type:

PS. C'est une solution de pis-aller et une très mauvaise pratique, ne doit jamais être utilisé lorsque vous savez que la base de données peut amener des milliers de dossiers...
```
query = query.ToList()
             .Where(x => x.FirstDate.Date == SecondDate.Date)
             .AsQueryable();
```
- P. S.: j'ai l'habitude de l'utiliser de cette façon, lorsque le DateTimes ont valeur de Temps et je veux comparer seulement la Date.
- c'est une très mauvaise solution, la requête va obtenir tous les enregistrements, et ensuite seulement de filtrer les dates. si la base de données a des millions d'enregistrements, cela attirera tous les d'eux, et alors seulement, filtre les dates. TRÈS MAUVAISE PRATIQUE.
- C'est une solution de pis-aller et une très mauvaise pratique, ne doit jamais être utilisé lorsque vous savez que la base de données peut amener des milliers d'enregistrements.
- si vous allez ajouter votre commentaire dans votre réponse, je vais enlever mon bas-vote. il devrait être clair pour tous ceux qui visitent cette page que la solution que vous avez proposée est mauvais sans avoir à lire les commentaires.
- la réponse a été édité.
InformationsquelleAutor Raskunho

Vous devez vous connecter pour publier un commentaire.