C# 你能教实体框架识别表达式吗？

我有一个使用实体框架的搜索功能。您可以搜索的内容之一是日期范围。您可能会说“开始日期在SearchStart和SearchEnd之间”。用linq语法编写并不困难，但当您有许多不同的日期参数可供搜索时，它可能会变得非常冗长

我在DateTime上有一个扩展方法，基本上检查日期是否包含在StartDate和EndDate之间。我在EF不是问题的其他地方使用它，但我也希望在EF查询中使用它。我通过在执行ToList（将尝试运行查询）之前应用额外的WHERE子句来动态创建查询

正如我所料，使用extension方法会引发异常： LINQ to Entities无法识别方法“Boolean IsBetween（System.DateTime，System.DateTime，System.DateTime）”方法，此方法无法转换为存储表达式

我知道LINQtoEntities无法知道在Sql中IsBetween转换为什么，但有没有一种方法可以让我给它提供指导？我试着在网上搜索答案，但没有多大帮助。如果有一些属性可以添加到扩展方法中，或者有一些方法可以更新EF配置

我猜不会，但我不想不问就假设

谢谢

更新：添加扩展方法代码

 public static bool IsBetween(this DateTime date , DateTime start, DateTime end)
 {
   return (date >= start && date < end);
 }

public static bool IsBetween（此日期时间日期、日期时间开始、日期时间结束）
{
返回（日期>=开始和日期<结束）；
}

您可以使用

DbFunctions

类在sql语句之间生成

在早于6.0的EF版本中称为
EntityFunctions
。
用法：

var start = new DateTime(2014, 01, 21);
var end = new DateTime(2014, 01, 22);
var queryable = dbContext.Set<MyEntity>();
queryable = queryable.InBetween(start, end);

var start=newdatetime（2014,01,21）；
var end=新日期时间（2014年1月22日）；
var queryable=dbContext.Set（）；
可查询=可查询。中间（开始、结束）；

扩展方法

public static class EntityExtensions
{
    public static IQueryable<MyEntity> InBetween(this IQueryable<MyEntity> queryable,
        DateTime start, DateTime end)
    {
        return queryable.Where(x => x.DateColumn >= start && x.DateColumn < end);
    }
}

公共静态类EntityExtensions
{
公共静态IQueryable中间（此IQueryable可查询，
日期时间开始，日期时间结束）
{
返回queryable.Where（x=>x.DateColumn>=start&&x.DateColumn

现在，您在这里无法完全重用其他扩展方法。但是，您可以在其他几个查询中重用这个新的扩展方法。只需在可查询项上调用.InBetween并传递参数

下面是另一种方法：

public static IQueryable<MyEntity> InBetween(this IQueryable<MyEntity> queryable,
    DateTime start, DateTime end)
{
    return queryable.Where(InBetween(start, end));
}

public static Expression<Func<MyEntity, bool>> InBetween(DateTime start,
    DateTime end)
{
    return x => x.DateColumn >= start && x.DateColumn < end;
}

公共静态IQueryable中间（此IQueryable可查询，
日期时间开始，日期时间结束）
{
返回可查询的。其中（介于（开始、结束）之间）；
}
中间的公共静态表达式（日期时间开始，
日期时间（结束）
{
返回x=>x.DateColumn>=start&&x.DateColumn
这里是一种完全通用的方法，但深入研究并手工构建表达式树以使其工作

我们不是在教实体框架如何读取新表达式，而是将表达式分解成实体框架已经知道如何读取的部分

public static IQueryable<T> IsBetween<T>(this IQueryable<T> query, Expression<Func<T, DateTime>> selector, DateTime start, DateTime end)
{
    //Record the start time and end time and turn them in to constants to be passed in to the query.
    //There may be a better way to pass them as parameters instead of constants but I don't have the skill with expression trees to know how to do it.
    var startTime = Expression.Constant(start);
    var endTime = Expression.Constant(end);

    //We get the body of the expression that was passed in that selects the DateTime column in the row for us.
    var selectorBody = selector.Body;

    //We need to pass along the parametres from that original selector.
    var selectorParameters = selector.Parameters;

    // Represents the "date >= start"
    var startCompare = Expression.GreaterThanOrEqual(selectorBody, startTime);

    // Represents the "date < end"
    var endCompare = Expression.LessThan(selectorBody, endTime);

    // Represents the "&&" between the two statements.
    var combinedExpression = Expression.AndAlso(startCompare, endCompare);

    //Reform the new expression in to a lambada to be passed along to the Where clause.
    var lambada = Expression.Lambda<Func<T, bool>>(combinedExpression, selectorParameters);

    //Perform the filtering and return the filtered query.
    return query.Where(lambada);
}

public static IQueryable IsBetween（此IQueryable查询、表达式选择器、日期时间开始、日期时间结束）
{
//记录开始时间和结束时间，并将它们转换为要传递给查询的常量。
//可能有更好的方法将它们作为参数而不是常量传递，但我不知道如何使用表达式树。
var startTime=表达式常数（开始）；
var endTime=表达式常数（结束）；
//我们得到传入的表达式的主体，该表达式为我们选择行中的DateTime列。
var selectorBody=selector.Body；
//我们需要传递原始选择器的参数。
var selectorParameters=选择器参数；
//表示“日期>=开始”
var startCompare=Expression.GreaterThanOrEqual（selectorBody，startTime）；
//表示“日期<结束”
var endCompare=Expression.LessThan（selectorBody，endTime）；
//表示两条语句之间的“&&”。
var combinedExpression=Expression.AndAlso（开始比较，结束比较）；
//将中的新表达式改为lambada，以传递给Where子句。
var lambada=Expression.Lambda（组合表达式、选择器或参数）；
//执行筛选并返回筛选后的查询。
返回query.Where（lambada）；
}

它生成以下SQL语句

SELECT 
    [Extent1].[TestId] AS [TestId], 
    [Extent1].[Example] AS [Example]
    FROM [dbo].[Tests] AS [Extent1]
    WHERE ([Extent1].[Example] >= convert(datetime2, '2013-01-01 00:00:00.0000000', 121)) AND ([Extent1].[Example] < convert(datetime2, '2014-01-01 00:00:00.0000000', 121))

选择
[Extent1][TestId]作为[TestId]，
[Extent1].[Example]作为[Example]
从[dbo].[Tests]到[Extent1]
其中（[Extent1].[Example]>=convert（datetime2，'2013-01-01 00:00:00.0000000'，121））和（[Extent1].[Example]

使用下面的程序

private static void Main(string[] args)
{
    using (var context = new TestContext())
    {
        context.SaveChanges();

        context.Tests.Add(new Test(new DateTime(2013, 6, 1)));
        context.Tests.Add(new Test(new DateTime(2014, 6, 1)));
        context.SaveChanges();

        DateTime start = new DateTime(2013, 1, 1);
        DateTime end = new DateTime(2014, 1, 1);

        var query = context.Tests.IsBetween(row => row.Example, start, end);

        var traceString = query.ToString();

        var result = query.ToList();

        Debugger.Break();
    }
}

public class Test
{
    public Test()
    {
        Example = DateTime.Now;
    }

    public Test(DateTime time)
    {
        Example = time;
    }

    public int TestId { get; set; }
    public DateTime Example { get; set; }
}

public class TestContext : DbContext
{
    public DbSet<Test> Tests { get; set; } 
}

private static void Main（字符串[]args）
{
使用（var context=newtestcontext（））
{
SaveChanges（）；
添加（新测试（新日期时间（2013,6,1））；
添加（新测试（新日期时间（2014,6,1））；
SaveChanges（）；
日期时间开始=新的日期时间（2013,1,1）；
DateTime end=新的日期时间（2014,1,1）；
var query=context.Tests.IsBetween（row=>row.Example，start，end）；
var traceString=query.ToString（）；
var result=query.ToList（）；
Debugger.Break（）；
}
}
公开课考试
{
公开考试（）
{
示例=DateTime.Now；
}
公共测试（日期时间）
{
示例=时间；
}
公共int TestId{get；set；}
公共日期时间示例{get；set；}
}
公共类TestContext:DbContext
{
公共数据库集测试{get；set；}
}


下面是一个可以转换通用表达式并将其映射到特定对象的实用程序。这允许您将表达式编写为
date=>date>=start&&date
，并将其传递到转换器进行映射
public static class LambadaConverter
{
    /// <summary>
    /// Converts a many parametered expression in to a single paramter expression using a set of mappers to go from the source type to mapped source.
    /// </summary>
    /// <typeparam name="TNewSourceType">The datatype for the new soruce type</typeparam>
    /// <typeparam name="TResult">The return type of the old lambada return type.</typeparam>
    /// <param name="query">The query to convert.</param>
    /// <param name="parameterMapping">The mappers to go from the single source class to a set of </param>
    /// <returns></returns>
    public static Expression<Func<TNewSourceType, TResult>>  Convert<TNewSourceType, TResult>(Expression query, params Expression[] parameterMapping)
    {
        //Doing some pre-condition checking to make sure everything was passed in correctly.
        var castQuery = query as LambdaExpression;

        if (castQuery == null)
            throw new ArgumentException("The passed in query must be a lambada expression", "query");

        if (parameterMapping.Any(expression => expression is LambdaExpression == false) ||
            parameterMapping.Any(expression => ((LambdaExpression)expression).Parameters.Count != 1) ||
            parameterMapping.Any(expression => ((LambdaExpression)expression).Parameters[0].Type != typeof(TNewSourceType)))
        {
            throw new ArgumentException("Each pramater mapper must be in the form of \"Expression<Func<TNewSourceType,TResut>>\"",
                                        "parameterMapping");
        }

        //We need to remap all the input mappings so they all share a single paramter variable.
        var inputParameter = Expression.Parameter(typeof(TNewSourceType));

        //Perform the mapping-remapping.
        var normlizer = new ParameterNormalizerVisitor(inputParameter);
        var mapping = normlizer.Visit(new ReadOnlyCollection<Expression>(parameterMapping));

        //Perform the mapping on the expression query.
        var customVisitor = new LambadaVisitor<TNewSourceType, TResult>(mapping, inputParameter);
        return (Expression<Func<TNewSourceType, TResult>>)customVisitor.Visit(query);

    }

    /// <summary>
    /// Causes the entire series of input lambadas to all share the same 
    /// </summary>
    private class ParameterNormalizerVisitor : ExpressionVisitor
    {
        public ParameterNormalizerVisitor(ParameterExpression parameter)
        {
            _parameter = parameter;
        }

        private readonly ParameterExpression _parameter;

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if(node.Type == _parameter.Type)
                return _parameter;
            else
                throw new InvalidOperationException("Was passed a parameter type that was not expected.");
        }
    }

    /// <summary>
    /// Rewrites the output query to use the new remapped inputs.
    /// </summary>
    private class LambadaVisitor<TSource,TResult> : ExpressionVisitor
    {
        public LambadaVisitor(ReadOnlyCollection<Expression> parameterMapping, ParameterExpression newParameter)
        {
            _parameterMapping = parameterMapping;
            _newParameter = newParameter;
        }

        private readonly ReadOnlyCollection<Expression> _parameterMapping;
        private readonly ParameterExpression _newParameter;

        private ReadOnlyCollection<ParameterExpression> _oldParameteres = null;

        protected override Expression VisitParameter(ParameterExpression node)
        {
            //Check to see if this is one of our known parameters, and replace the body if it is.
            var index = _oldParameteres.IndexOf(node);
            if (index >= 0)
            {
                return ((LambdaExpression)_parameterMapping[index]).Body;
            }

            //Not one of our known parameters, process as normal.
            return base.VisitParameter(node);
        }

        protected override Expression VisitLambda<T>(Expression<T> node)
        {
            if (_oldParameteres == null)
            {
                _oldParameteres = node.Parameters;

                var newBody = this.Visit(node.Body);

                return Expression.Lambda<Func<TSource, TResult>>(newBody, _newParameter);
            }
            else
                throw new InvalidOperationException("Encountered more than one Lambada, not sure how to handle this.");
        }
    }
}

    private static void Main(string[] args)
    {
        using (var context = new TestContext())
        {
            DateTime start = new DateTime(2013, 1, 1);
            DateTime end = new DateTime(2014, 1, 1);

            var query = context.Tests.IsBetween(row => row.Example, start, end);
            var traceString = query.ToString(); // Generates the where clause: WHERE ([Extent1].[Example] >= @p__linq__0) AND ([Extent1].[Example] < @p__linq__1)

            var query2 = context.Tests.ComplexTest(row => row.Param1, row => row.Param2);
            var traceString2 = query2.ToString(); //Generates the where clause: WHERE (N'Foo' = [Extent1].[Param1]) AND ([Extent1].[Param1] IS NOT NULL) AND (2 = [Extent1].[Param2])

            Debugger.Break();
        }
    }

    public class Test
    {
        public int TestId { get; set; }
        public DateTime Example { get; set; }
        public string Param1 { get; set; }
        public int Param2 { get; set; }
    }

    public class TestContext : DbContext
    {
        public DbSet<Test> Tests { get; set; } 
    }

    public static IQueryable<T> IsBetween<T>(this IQueryable<T> query, Expression<Func<T, DateTime>> dateSelector, DateTime start, DateTime end)
    {
        Expression<Func<DateTime, bool>> testQuery = date => date >= start && date < end;

        var newQuery = LambadaConverter.Convert<T, bool>(testQuery, dateSelector);

        return query.Where(newQuery);
    }

    public static IQueryable<T> ComplexTest<T>(this IQueryable<T> query, Expression<Func<T, string>> selector1, Expression<Func<T, int>> selector2)
    {
        Expression<Func<string, int, bool>> testQuery = (str, num) => str == "Foo" && num == 2;

        var newQuery = LambadaConverter.Convert<T, bool>(testQuery, selector1, selector2);

        return query.Where(newQuery);
    }