Question

I need to build a “between” function to check if a date is included in a range of 2 dates. I wrote this, but it doesn’t work:

private static Expression<Func<TElement, bool>> IsDateBetween<TElement>(Expression<Func<TElement, object>> valueSelector, DateTime date)
{
    var p = valueSelector.Parameters.Single();

    var after = Expression.LessThanOrEqual(
        Expression.Property(valueSelector.Body, "FromDate"), Expression.Constant(date.Date, typeof(DateTime)));

    var before = Expression.GreaterThanOrEqual(
        Expression.Property(valueSelector.Body, "ToDate"), Expression.Constant(date.Date, typeof(DateTime)));

    Expression body = Expression.And(after, before);

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

I call it in this way:

DataContext.EventHistories.Where(IsDateBetween<EventHistory>(h => new { h.FromDate, h.ToDate }, dateInTheMiddle))

I must use this way because date not supported in linq entities.

Thanks

Answer 1

You could try something like that

public static IQueryable<TElement> IsDateBetween<TElement>(this IQueryable<TElement> queryable, 
                                                           Expression<Func<TElement, DateTime>> fromDate, 
                                                           Expression<Func<TElement, DateTime>> toDate, 
                                                           DateTime date)
{
    var p = fromDate.Parameters.Single();
    Expression member = p;

    Expression fromExpression = Expression.Property(member, (fromDate.Body as MemberExpression).Member.Name);
    Expression toExpression = Expression.Property(member, (toDate.Body as MemberExpression).Member.Name);

    var after = Expression.LessThanOrEqual(fromExpression,
         Expression.Constant(date, typeof(DateTime)));

    var before = Expression.GreaterThanOrEqual(
        toExpression, Expression.Constant(date, typeof(DateTime)));

    Expression body = Expression.And(after, before);

    var predicate = Expression.Lambda<Func<TElement, bool>>(body, p);
    return queryable.Where(predicate);
}

usage

DataContext.EventHistories.WhereDateBetween(h =>  h.FromDate, h => h.ToDate, dateInTheMiddle));

but it’s quite complicated to do

var myDate = DateTime.Now();

var result = DataContext.EventHistories.Where(m => m.FromDate >= myDate && m.ToDate<=myDate );

EDIT

Well, to simulate the DateTime.Date, you could do :

var myDate = DateTime.Now.Date();
var res = histories.AsQueryable()
.Where(m => 
EntityFunctions.CreateDateTime(m.FromDate.Year, m.FromDate.Month, m.FromDate.Day, 0, 0, 0) >= DateTime.Now && 
EntityFunctions.CreateDateTime(m.ToDate.Year, m.ToDate.Month, m.ToDate.Day, 0, 0, 0) <= DateTime.Now)

Or create an interface

public interface IFromDateToDate
{
    DateTime FromDate { get; set; }
    DateTime ToDate { get; set; }
}

and an extension method

public static IQueryable<T> WhereDatesBetween<T>(this IQueryable<T> queryable, DateTime myDate) where T : IFromDateToDate
{
    myDate = myDate.Date;
    return queryable.Where(m =>
                           EntityFunctions.CreateDateTime(m.FromDate.Year, m.FromDate.Month, m.FromDate.Day, 0, 0, 0) >= myDate &&
                           EntityFunctions.CreateDateTime(m.FromDate.Year, m.FromDate.Month, m.FromDate.Day, 0, 0, 0) <= myDate);
}

usage :

DataContext.EventHistories.WhereDatesBetween(dateInTheMiddle));