c# - 让 EF Linq Select 语句选择常量或函数

Question

我有一个 Select 语句，当前格式如下

dbEntity
.GroupBy(x => x.date)
.Select(groupedDate => new {
                             Calculation1 = doCalculation1 ? x.Sum(groupedDate.Column1) : 0),
                             Calculation2 = doCalculation2 ? x.Count(groupedDate) : 0)

在查询中，doCalculation1 和 doCalculation2 是先前设置的 bool 值。这会在正在生成的 Sql 中创建一个 case 语句，例如

DECLARE @p1 int = 1
DECLARE @p2 int = 0
DECLARE @p3 int = 1
DECLARE @p4 int = 0
SELECT (Case When @p1 = 1 THEN Sum(dbEntity.Column1)
     Else @p2
     End) as Calculation1,
     (Case When @p3 = 1 THEN Count(*)
     Else @p4
     End) as Calculation2

我想要发生的是，当 doCalculation1 为真时，生成的 sql 是这样的

SELECT SUM(Column1) as Calculation1, Count(*)  as Calculation2

当 doCalculation2 为 false 时像这样

SELECT 0 as Calculation1, Count(*) as Calculation2

有什么方法可以通过 EF 强制执行这样的查询吗？

编辑:

bool doCalculation = true;
bool doCalculation2 = false;
            dbEntity
            .Where(x => x.FundType == "E")
            .GroupBy(x => x.ReportDate)
              .Select(dateGroup => new 
              {
                  ReportDate = dateGroup.Key,
                  CountInFlows = doCalculation2 ? dateGroup.Count(x => x.Flow > 0) : 0,
                  NetAssetEnd = doCalculation ? dateGroup.Sum(x => x.AssetsEnd) : 0
              })
              .ToList();

生成这个sql

-- Region Parameters
DECLARE @p0 VarChar(1000) = 'E'
DECLARE @p1 Int = 0
DECLARE @p2 Decimal(5,4) = 0
DECLARE @p3 Int = 0
DECLARE @p4 Int = 1
DECLARE @p5 Decimal(1,0) = 0
-- EndRegion
SELECT [t1].[ReportDate], 
    (CASE 
        WHEN @p1 = 1 THEN (
            SELECT COUNT(*)
            FROM [dbEntity] AS [t2]
            WHERE ([t2].[Flow] > @p2) AND ([t1].[ReportDate] = [t2].[ReportDate]) AND ([t2].[FundType] = @p0)
        )
        ELSE @p3
     END) AS [CountInFlows], 
    (CASE 
        WHEN @p4 = 1 THEN CONVERT(Decimal(33,4),[t1].[value])
        ELSE CONVERT(Decimal(33,4),@p5)
     END) AS [NetAssetEnd]
FROM (
    SELECT SUM([t0].[AssetsEnd]) AS [value], [t0].[ReportDate]
    FROM [dbEntity] AS [t0]
    WHERE [t0].[FundType] = @p0
    GROUP BY [t0].[ReportDate]
    ) AS [t1]

在执行计划中有很多索引扫描和一个假脱机和一个连接。在测试集上运行平均需要大约 20 秒，生产集会更大。

我希望它和sql like一样的速度运行

select reportdate, 1, sum(AssetsEnd)
from vwDailyFundFlowDetail
where fundtype = 'E'
group by reportdate

平均运行时间约为 12 秒，并且大部分查询都绑定(bind)在执行计划中的单个索引查找中。实际的 sql 输出是什么并不重要，但 case 语句的性能似乎要差得多。

至于我为什么这样做，我需要生成一个动态选择语句，就像我在 Dynamically generate Linq Select 中问的那样.用户可以选择一组计算中的一个或多个来执行，在请求进来之前我不知道选择了什么。请求很昂贵，所以我们不想运行它们，除非它们是必要的。我正在根据用户请求设置 doCalculation bool 值。

这个查询应该替换一些代码，这些代码从存储为字符串的硬编码 sql 查询中插入或删除字符，然后执行。运行速度相当快，但维护起来是一场噩梦

Answer 1

技术上可以通过 an expression tree visitor 在您的 Select 查询中传递表达式，它检查三元运算符左侧的常量值，并用适当的子表达式替换三元表达式。

例如:

public class Simplifier : ExpressionVisitor
{
    public static Expression<T> Simplify<T>(Expression<T> expr)
    {
        return (Expression<T>) new Simplifier().Visit(expr);
    }

    protected override Expression VisitConditional(ConditionalExpression node)
    {
        var test = Visit(node.Test);
        var ifTrue = Visit(node.IfTrue);
        var ifFalse = Visit(node.IfFalse);

        var testConst = test as ConstantExpression;
        if(testConst != null)
        {
            var value = (bool) testConst.Value;
            return value ? ifTrue : ifFalse;
        }

        return Expression.Condition(test, ifTrue, ifFalse);
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        // Closed-over variables are represented as field accesses to fields on a constant object.
        var field = (node.Member as FieldInfo);
        var closure = (node.Expression as ConstantExpression);
        if(closure != null)
        {
            var value = field.GetValue(closure.Value);
            return VisitConstant(Expression.Constant(value));
        }
        return base.VisitMember(node);
    }
}

使用示例:

void Main()
{
    var b = true;
    Expression<Func<int, object>> expr = i => b ? i.ToString() : "N/A";
    Console.WriteLine(expr.ToString()); // i => IIF(value(UserQuery+<>c__DisplayClass0).b, i.ToString(), "N/A")
    Console.WriteLine(Simplifier.Simplify(expr).ToString()); // i => i.ToString()
    b = false;
    Console.WriteLine(Simplifier.Simplify(expr).ToString()); // i => "N/A"
}

因此，您可以在您的代码中像这样使用它:

Expression<Func<IGrouping<DateTime, MyEntity>>, ClassYouWantToReturn> select = 
    groupedDate => new {
        Calculation1 = doCalculation1 ? x.Sum(groupedDate.Column1) : 0),
        Calculation2 = doCalculation2 ? x.Count(groupedDate) : 0
    };
var q = dbEntity
    .GroupBy(x => x.date)
    .Select(Simplifier.Simplify(select))

然而，这可能比它的值(value)更麻烦。 SQL Server 几乎毫无疑问会优化“1 == 1”的情况，允许 Entity Framework 生成不太漂亮的查询不应被证明是性能问题。

更新

查看更新后的问题，这似乎是生成正确查询确实对性能很重要的少数几个实例之一。

除了我建议的解决方案外，还有一些其他选择:您可以 use raw sql映射到您的返回类型，或者您可以使用 LinqKit根据需要选择不同的表达式，然后在 Select 查询中“调用”该表达式。