¿Cómo comparar solo los componentes de fecha de DateTime en EF?

Tengo dos valores de fecha, uno ya almacenado en la base de datos y el otro seleccionado por el usuario usando DatePicker. El caso de uso es buscar una fecha particular en la base de datos.

El valor ingresado previamente en la base de datos siempre tiene un componente de hora de 12:00:00, mientras que la fecha ingresada desde el selector tiene un componente de tiempo diferente.

Solo estoy interesado en los componentes de fecha y me gustaría ignorar el componente de tiempo.

¿Cuáles son las formas de hacer esta comparación en C #?

Además, ¿cómo hacer esto en LINQ?

ACTUALIZACIÓN: En LINQ to Entities, lo siguiente funciona bien.

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

NOTA: en el momento de escribir esta respuesta, la relación EF no estaba clara (que se editó en la pregunta después de que se escribió esto). Para un enfoque correcto con EF, verifique la respuesta de Mandeeps .

Puede utilizar la DateTime.Datepropiedad para realizar una comparación de solo fecha.

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

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

Utilice la clase EntityFunctionspara recortar la parte de tiempo.

using System.Data.Objects;    

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

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

ACTUALIZAR

A partir de EF 6.0 y posteriores, EntityFunctions se reemplaza por DbFunctions .

Creo que esto podría ayudarte.

Hice una extensión porque tengo que comparar fechas en repositorios llenos de datos EF y, por lo tanto, .Date no era una opción ya que no está implementado en la traducción de LinqToEntities.

Aquí está el código:

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

entonces puedes usarlo de esta manera.

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

Si usa la Datepropiedad para entidades de base de datos, obtendrá una excepción:

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

Puedes usar algo como esto:

  DateTime date = DateTime.Now.Date;

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

Para hacerlo en LINQ to Entities, debe usar métodos compatibles :

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

Feo, pero funciona y está hecho en el servidor de base de datos.

Aquí hay una forma diferente de hacerlo, pero solo es útil si SecondDate es una variable que está pasando:

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

Creo que debería funcionar

También puedes usar esto:

DbFunctions.DiffDays(date1, date2) == 0

puede usar el método DbFunctions.TruncateTime () para esto.

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

Simplemente compare siempre la propiedad Date de DateTime, en lugar de la fecha y hora completa.

Cuando realice su consulta LINQ, use date.Date en la consulta, es decir:

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

Así es como hago esto.

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 para usuarios / codificadores de Linq

Esto debería brindarle la comparación exacta para verificar si una fecha está dentro del rango cuando se trabaja con la entrada de un usuario, por ejemplo, selector de fechas:

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

donde fecha de inicio y fecha de finalización son valores de un selector de fechas.

Sin tiempo que intentar así:

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;

Puede utilizar el siguiente enlace para comparar 2 fechas sin tiempo:

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 función Comparar devuelve 3 valores diferentes: -1 0 1 que significa dt1> dt2, dt1 = dt2, dt1

Pruebe esto ... Funciona bien para comparar las propiedades de fecha entre dos tipos de fecha y hora:

PD. Es una solución provisional y una práctica realmente mala, nunca debe usarse cuando se sabe que la base de datos puede traer miles de registros ...

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