组合 LINQ 的表达式

Question

我在下面有一个大代码块，实际代码并不那么重要，但包含在内是为了演示我正在尝试做的事情。

我有一个公共静态表达式> GetFreeSpotCount(...)

这个方法返回一个我想在另一个方法中重用的表达式

表达式本身返回一个数字，表示 [model] 列表中满足特定条件的 [model] 的数量。

我希望新方法返回上面数字大于 0 的所有 [model]。

下面是我目前的代码，我想避免重复这么多代码

public static Expression<Func<ExamTimeSlot, int>> GetFreeSpotCountFor(List<Guid> drivingSchoolIds)
{
    return ets =>
    ets.Participants
        - ets.Exams.Where(ex => ex.Status == ExamStatus.Pending).Count(e => !ets.ExamTimeSlotReservations.Any(r => r.DrivingSchoolId == e.BookedByDrivingSchoolId))
        - ((int?)ets.ExamTimeSlotReservations.Sum(r => (ets.Exams.Where(ex => ex.Status == ExamStatus.Pending).Where(e => e.BookedByDrivingSchoolId == r.DrivingSchoolId).Count()
            - r.ReservedSpots) > 0 ? (ets.Exams.Where(ex => ex.Status == ExamStatus.Pending).Where(e => e.BookedByDrivingSchoolId == r.DrivingSchoolId).Count() - r.ReservedSpots) : 0) ?? 0)
        - ((int?)ets.ExamTimeSlotReservations.Sum(r => r.ReservedSpots) ?? 0)
        + ((((int?)ets.ExamTimeSlotReservations.Where(r => drivingSchoolIds.Any(id => r.DrivingSchoolId == id)).Sum(r => r.ReservedSpots) ?? 0)
            - ets.Exams.Where(ex => drivingSchoolIds.Any(id => ex.BookedByDrivingSchoolId == id) && ex.Status == ExamStatus.Pending).Count()) >= 0 ?
                (((int?)ets.ExamTimeSlotReservations.Where(r => drivingSchoolIds.Any(id => r.DrivingSchoolId == id)).Sum(r => r.ReservedSpots) ?? 0)
                - ets.Exams.Where(ex => drivingSchoolIds.Any(id => ex.BookedByDrivingSchoolId == id) && ex.Status == ExamStatus.Pending).Count())
                : 0);
}

和：

public static Expression<Func<ExamTimeSlot, bool>> GetExamTimeSlotsWithFreeSpotsFor(List<Guid> drivingSchoolIds)
{
    return ets =>
    (ets.Participants
        - ets.Exams.Where(ex => ex.Status == ExamStatus.Pending).Count(e => !ets.ExamTimeSlotReservations.Any(r => r.DrivingSchoolId == e.BookedByDrivingSchoolId))
        - ((int?)ets.ExamTimeSlotReservations.Sum(r => (ets.Exams.Where(ex => ex.Status == ExamStatus.Pending).Where(e => e.BookedByDrivingSchoolId == r.DrivingSchoolId).Count()
            - r.ReservedSpots) > 0 ? (ets.Exams.Where(ex => ex.Status == ExamStatus.Pending).Where(e => e.BookedByDrivingSchoolId == r.DrivingSchoolId).Count() - r.ReservedSpots) : 0) ?? 0)
        - ((int?)ets.ExamTimeSlotReservations.Sum(r => r.ReservedSpots) ?? 0)
        + ((((int?)ets.ExamTimeSlotReservations.Where(r => drivingSchoolIds.Any(id => r.DrivingSchoolId == id)).Sum(r => r.ReservedSpots) ?? 0)
            - ets.Exams.Where(ex => drivingSchoolIds.Any(id => ex.BookedByDrivingSchoolId == id) && ex.Status == ExamStatus.Pending).Count()) >= 0 ?
                (((int?)ets.ExamTimeSlotReservations.Where(r => drivingSchoolIds.Any(id => r.DrivingSchoolId == id)).Sum(r => r.ReservedSpots) ?? 0)
                - ets.Exams.Where(ex => drivingSchoolIds.Any(id => ex.BookedByDrivingSchoolId == id) && ex.Status == ExamStatus.Pending).Count())
                : 0)) > 0;
}

我想做这样的事情：

public static Expression<Func<ExamTimeSlot, bool>> GetExamTimeSlotsWithFreeSpotsFor(List<Guid> drivingSchoolIds)
{
    return ets => GetFreeSpotCountFor(drivingSchoolIds) > 0;
}

我曾尝试将 Expression.GreaterThan 与第一个表达式一起使用，但由于我需要结果 AND [model]，因此我无法找到使其工作的方法。

Answer 1

真的没有更简单的方法（没有第三方库）来做到这一点。看起来我们应该很容易就能做到你所写的，但是我们被误导了，因为我们在创建表达式树时依赖于语法糖。

public static Expression<Func<ExamTimeSlot, bool>> GetExamTimeSlotsWithFreeSpotsFor(List<Guid> drivingSchoolIds)
{
    var param = Expression.Parameter(typeof(ExamTimeSlot));

    //We want to create a new lambda which will invoke `GetFreeSpotCountFor` with our parameter, and then check it's greater than 0
    var newBody = 
        Expression.GreaterThan(
            //View this as GetFreeSpotCountFor(drivingSchoolIds)(param) - where param will be given to us when this lambda is invoked
            Expression.Invoke(
                GetFreeSpotCountFor(drivingSchoolIds),
                param
            ),
            //Pass the right-hand value (0) to the GreaterThan check
            Expression.Constant(0)
        );

    var lambda = Expression.Lambda<Func<ExamTimeSlot, bool>>(newBody, param);
    return lambda;
}

获得Expression 对象后，我们需要手动构建表达式树。

上面会将您的 lambda 包装在一个新的 lambda 中，该 lambda 调用并将结果与​​ 0 进行比较。另一种方法是检查现有 lambda 的 .Body，并将 .GreaterThan 附加到它，并返回一个全新的 lambda。

即：

public static Expression<Func<ExamTimeSlot, bool>> GetExamTimeSlotsWithFreeSpotsFor(List<Guid> drivingSchoolIds)
{
    //This grabs the existing lambda, which we will work on
    var oldLambda = GetFreeSpotCountFor(drivingSchoolIds);
    var newBody = 
        //Invoke `GreaterThan` directly on the old lambda's Body
        Expression.GreaterThan(
            oldLambda.Body,
            //Pass the right-hand value (0) to the GreaterThan check
            Expression.Constant(0)
        );

    //Now, we need to pass in the old parameters, and build a new lambda.
    var lambda = Expression.Lambda<Func<ExamTimeSlot, bool>>(newBody, oldLambda.Parameters);
    return lambda;
}

Answer 2

为什么你特别想组合表达式而不是组合查询调用？一种简单的方法是让您的 GetExamTimeSlotsWithFreeSpotsFor 不接受并返回表达式，而是接受并返回查询，并向该查询添加两个 where 子句（每个都是您存储的表达式）。

  public static IQueryable<ExamTimeSlot> WhereExamTimeSlotsWithFreeSpotsFor (IQueryable<ExamTimeSlot> Source, List<Guid> drivingSchoolIds)
  {
       var FirstFilter = GetFreeSpotCountFor(drivingSchoolIds);
       var SecondFilter = GetExamTimeSlotsWithFreeSpotsFor(drivingSchoolIds);
       return Source
              .Where(FirstFilter)
              .Where(SecondFilter);                   
  }

这样你就不需要组合任何东西，让你的 LINQ 提供者自己组合两个 where 子句。

请注意，如果您真的想手动组合表达式，这是可能的，但据我所知，它需要第三方 API 或直接使用表达式树（不仅仅是享受编译器为您做的魔法）。如果只是返回一个接受 2 个表达式并在其间使用 and 运算符的表达式，这并不难，但对于相同的结果来说，这似乎有点过头了。