Question

我有一个查询，可以选择我的班级列表。它看起来像这样：

IQueryable<ClaimsBySupplierAggregate> agg = 
  (from d in alliance.SupplierSearchByReviewPeriod
   where d.ClientID == ClientID && ReviewPeriodIDs.Contains((int)d.ReviewPeriodID)

   select new ClaimsBySupplierAggregate {
       Amount = d.Amount,
       StatusCategoryID = d.StatusCategoryID,
       DeptName = d.DepartmentName,
       APLReason = d.APLReason,
       Area = d.AreaDesc,
       StatusCategoryDesc = d.StatusCategoryDesc,
       Agreed = d.Agreed
   });

稍后在应用程序中我选择每个变量并得到如下的不同值：

SupplierModel.APLReason = agg.Select(r => r.APLReason).Distinct().ToList();
SupplierModel.AreaDesc = agg.Select(r => r.Area).Distinct().ToList();
SupplierModel.DeptName = agg.Select(r => r.DeptName).Distinct().ToList();
SupplierModel.StatCatDes = aggg.Select(r => r.StatusCategoryDesc).Distinct().ToList();

有没有办法在一个LINQ语句中执行此操作？

Answer 1

您可以使用Aggregate，但是您需要一个复杂的种子对象，这会带来相同的代码复杂性。我认为对于这个特殊情况，使用LInQ进入Golden Hammer反模式。只需使用一个旧的循环和四个HashSets而不是Lists，你就完成了，代码更具可读性，你的意图更清晰。

Answer 2

我认为你可以使用它，然后根据你的期望自定义代码。或者你可以使用group by。

public class LinqTest
    {
        public int id { get; set; }
        public string value { get; set; }

        public override bool Equals(object obj)
        {
            LinqTest obj2 = obj as LinqTest;
            if (obj2 == null) return false;
            return id == obj2.id;
        }

        public override int GetHashCode()
        {
            return id;
        }
    }

    List<LinqTest> uniqueIDs = myList.Distinct().ToList();

Answer 3

有一种人为的方法：

from d in alliance.SupplierSearchByReviewPeriod
where d.ClientID == ClientID && ReviewPeriodIDs.Contains((int)d.ReviewPeriodID)
group d by 0 into g
select new
{
    APLReasons = g.Select(d => d.APLReason).Distinct(),
    AreaDescs = g.Select(d => d.Area).Distinct(),
    DeptNames = g.Select(d => d.DeptName).Distinct(),
    StatusCategoryDescs = g.Select(d => d.StatusCategoryDesc).Distinct(),
}

部分group d by 0 into g创建一组所有项目，您可以随后查询所需的任何聚合。

但是...

...这会使用UNION和（当然）DISTINCT创建效率非常低的查询。简单地从数据库中获取平面数据并在后续代码中进行聚合可能更好（性能方面）。

LINQ在不同变量上选择不同的

3 个答案: