Come confrontare solo i componenti della data da DateTime in EF?

Ho due valori di data, uno già memorizzato nel database e l'altro selezionato dall'utente utilizzando DatePicker. Il caso d'uso è cercare una data particolare dal database.

Il valore precedentemente inserito nel database ha sempre una componente temporale di 12:00:00, dove la data inserita dal selettore ha una componente temporale diversa.

Sono interessato solo ai componenti della data e vorrei ignorare il componente dell'ora.

Quali sono i modi per eseguire questo confronto in C #?

Inoltre, come eseguire questa operazione in LINQ?

AGGIORNAMENTO: su LINQ to Entities, quanto segue funziona correttamente.

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

NOTA: al momento della stesura di questa risposta, la relazione EF non era chiara (che è stata modificata nella domanda dopo che è stata scritta). Per un approccio corretto con EF, controlla la risposta di Mandeep .

È possibile utilizzare la DateTime.Dateproprietà per eseguire un confronto di sola data.

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

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

Usa la classe EntityFunctionsper tagliare la porzione di tempo.

using System.Data.Objects;    

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

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

AGGIORNARE

A partire da EF 6.0 e versioni successive, EntityFunctions è stato sostituito da DbFunctions .

Penso che questo potrebbe aiutarti.

Ho fatto un'estensione poiché devo confrontare le date nei repository pieni di dati EF e quindi .Date non era un'opzione poiché non è implementata nella traduzione di LinqToEntities.

Ecco il codice:

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

allora puoi usarlo in questo modo.

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

Se utilizzi la Dateproprietà per le entità database, otterrai un'eccezione:

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

Puoi usare qualcosa del genere:

  DateTime date = DateTime.Now.Date;

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

Per farlo in LINQ to Entities, devi utilizzare metodi supportati :

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

Brutto, ma funziona e viene eseguito sul server DB.

Ecco un modo diverso per farlo, ma è utile solo se SecondDate è una variabile che stai passando:

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

Penso che dovrebbe funzionare

Puoi anche usare questo:

DbFunctions.DiffDays(date1, date2) == 0

puoi usare il metodo DbFunctions.TruncateTime () per questo.

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

Basta confrontare sempre la proprietà Date di DateTime, invece dell'ora della data completa.

Quando si effettua la query LINQ, utilizzare date.Date nella query, ad esempio:

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

Ecco come lo faccio.

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

// Nota per utenti / programmatori Linq

Questo dovrebbe darti il ​​confronto esatto per controllare se una data rientra nell'intervallo quando lavori con l'input di un utente - ad esempio il selettore di date:

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

dove startdate e enddate sono valori di un selettore di date.

Senza tempo che provare in questo modo:

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;

È possibile utilizzare il collegamento sottostante per confrontare 2 date senza tempo:

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 funzione Confronta restituisce 3 valori diversi: -1 0 1 che significa dt1> dt2, dt1 = dt2, dt1

Prova questo ... Funziona bene per confrontare le proprietà Date tra due tipi DateTimes:

PS. È una soluzione provvisoria e una pratica davvero pessima, non dovrebbe mai essere usata quando sai che il database può portare migliaia di record ...

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