4

我目前有这个样本数据表：

ID  | Policy ID     |   History ID  | Policy name
1   |   1           |    0          | Test
2   |   1           |    1          | Test
3   |   2           |    0          | Test1
4   |   2           |    1          | Test1

其中，我想按策略 ID 和历史 ID (MAX) 进行分组，所以我要保留的记录是 ID 的 2 和 4：

   ID   | Policy ID     |   History ID  | Policy name
    2   |   1           |    1          | Test
    4   |   2           |    1          | Test1

我尝试在 LINQ 中执行此操作，并且每次都遇到相同的问题。我可以将我的实体分组，但总是将它们分组到一个我必须重新定义属性的组中，而不是让它们从我的 Policy 对象中保留下来。如：

var policies = _context.Policies.GroupBy(a => a.intPolicyId)
                                            .Select(group => new {
                                                PolicyID = group.Key,
                                                HistoryID = group.Max(a => a.intHistoryID)
                                            });

这只是带出一个对象列表，其中包含“策略 ID”和“历史 ID”。我想要从 Policies 对象返回的所有属性，而不必重新定义它们，因为该对象中有大约 50 多个属性。

我试过：

        var policies = _context.Policies.GroupBy(a => a.intPolicyId)
                                                    .Select(group => new {
                                                        PolicyID = group.Key,
                                                        HistoryID = group.Max(a => a.intHistoryID)
                                                        PolicyObject = group;
                                                    });

但这会出错。

有任何想法吗？

4

2 回答 2

3

按复合键分组

_context.Policies.GroupBy(a => new {a.intPolicyId, *other fields*}).Select(
    group=> new {
        PolicyId = group.Key.intPolicyId,
        HistoryId = group.Max(intHistoryId),
        *other fields*
    }
);

另一种方法 - 获取历史记录，而不是加入其余数据，像这样（不能开箱即用，需要一些改进）

var historyIDs = _context.Policies.GroupBy(a=>a.intPolicyId).Select(group => new {
                                            PolicyID = group.Key,
                                            HistoryID = group.Max(a => a.intHistoryID)
                                        });

var finalData = from h in historyIDs
                join p in _context.Policies on h.intPolicyId equals p.intPolicyId
                select new {h.HistoryId, *all other policy fields*}

还有另一种方式，更简单，不需要大量输入:)：

var historyIDs = _context.Policies.GroupBy(a=>a.intPolicyId).Select(group => new {
                                            PolicyID = group.Key,
                                            HistoryID = group.Max(a => a.intHistoryID)
                                        });

var finalData = from h in historyIDs
                join p in _context.Policies on h.PolicyId equals p.intPolicyId && h.HistoryId equals p.HistoryId
                select p

基本上它有点等价于下面的 SQL 查询：

select p.*
from Policy p
inner join (
    select pi.policyId, max(pi.historyId)
    from Policy pi
    group by pi.policyId
) pp on pp.policyId = p.policyId and pp.historyId = p.historyId
于 2012-11-15T15:17:53.877 回答
0

在 LINQ to Objects 中，我会这样做

var policies = _context.Policies
    .GroupBy(a => a.intPolicyId)
    .Select(g => g.OrderByDescending(p => p.intHistoryID).First());

但你的_contextimpleis 可能涉及一个数据库，我不能 100% 确定这会翻译。

基本上它按您所期望的策略 ID 分组，然后在每个组中按历史 ID 排序，并从每个组中选择具有最高历史 ID 的行。它返回的类型与Policies.

于 2012-11-15T15:21:14.923 回答