C# 用LINQ求几个和的最大值

我有一个名为UserActivity的表，它有ActivityId和Points列。条目不是唯一的，因此有许多行具有相同的ActivityId。我想要的是汇总每个活动的所有分数，然后返回ActivityId和分数最多的活动的分数。因此，在SQL中，类似这样的内容（未经测试）：

我如何在LINQ实现这一点？我对它是全新的，所以我根本不知道我在做什么

---

---

所有伟大的答案，各位！最后，我从他们每个人身上都学到了一些东西。谢谢。

您可以按活动ID分组，对每个活动的分数求和，按总和降序排序，然后获取第一个结果

db.UserActivity
.GroupBy(m => m.ActivityId)
.Select(m => new {
   activityId = m.Key,
   sumPoints = m.Sum(x => x.Points)
})
.OrderByDescending(x => x.sumPoints)
.First()
.activityId;

可以简化为

db.UserActivity
    .GroupBy(m => m.ActivityId)
    .OrderByDescending(x => x.Sum(s => s.Points))
    .First()
    .Key;

---

您可以按activityid分组，对每个活动的点数求和，按总和降序排序，并获取第一个结果

db.UserActivity
.GroupBy(m => m.ActivityId)
.Select(m => new {
   activityId = m.Key,
   sumPoints = m.Sum(x => x.Points)
})
.OrderByDescending(x => x.sumPoints)
.First()
.activityId;

可以简化为

db.UserActivity
    .GroupBy(m => m.ActivityId)
    .OrderByDescending(x => x.Sum(s => s.Points))
    .First()
    .Key;

---

您可以按activityid分组，对每个活动的点数求和，按总和降序排序，并获取第一个结果

db.UserActivity
.GroupBy(m => m.ActivityId)
.Select(m => new {
   activityId = m.Key,
   sumPoints = m.Sum(x => x.Points)
})
.OrderByDescending(x => x.sumPoints)
.First()
.activityId;

可以简化为

db.UserActivity
    .GroupBy(m => m.ActivityId)
    .OrderByDescending(x => x.Sum(s => s.Points))
    .First()
    .Key;

---

您可以按activityid分组，对每个活动的点数求和，按总和降序排序，并获取第一个结果

db.UserActivity
.GroupBy(m => m.ActivityId)
.Select(m => new {
   activityId = m.Key,
   sumPoints = m.Sum(x => x.Points)
})
.OrderByDescending(x => x.sumPoints)
.First()
.activityId;

可以简化为

db.UserActivity
    .GroupBy(m => m.ActivityId)
    .OrderByDescending(x => x.Sum(s => s.Points))
    .First()
    .Key;

---

您正在尝试创建自己的StackOverflow吗？：-）

IEnumerable UserActivities=LoadUserActivities（）；
int maxTotalPointsActivityId=
用户活动
.GroupBy（ua=>ua.ActivityId）
.OrderByDescending（uaGp=>uaGp.Sum（ua=>ua.Points））
.First（）
钥匙

您正在尝试创建自己的StackOverflow吗？：-）

IEnumerable UserActivities=LoadUserActivities（）；
int maxTotalPointsActivityId=
用户活动
.GroupBy（ua=>ua.ActivityId）
.OrderByDescending（uaGp=>uaGp.Sum（ua=>ua.Points））
.First（）
钥匙

您正在尝试创建自己的StackOverflow吗？：-）

IEnumerable UserActivities=LoadUserActivities（）；
int maxTotalPointsActivityId=
用户活动
.GroupBy（ua=>ua.ActivityId）
.OrderByDescending（uaGp=>uaGp.Sum（ua=>ua.Points））
.First（）
钥匙

您正在尝试创建自己的StackOverflow吗？：-）

IEnumerable UserActivities=LoadUserActivities（）；
int maxTotalPointsActivityId=
用户活动
.GroupBy（ua=>ua.ActivityId）
.OrderByDescending（uaGp=>uaGp.Sum（ua=>ua.Points））
.First（）
钥匙

如果您只想要一个结果，即使有多个活动的分数最多

var activityWithMostPoints = db.UserActivity
                            .GroupBy(a => a.ActivityId, 
                                     (k, g) => new { 
                                        ActivityId = k, 
                                        TotalPoints = g.Select(a => a.Points).Sum() 
                                    })
                            .OrderByDescending(a => a.TotalPoints)
                            .First();

您提供的SQL查询实际上将返回所有具有最多点数的活动。这有点复杂，而且可能效率低下，这取决于生成的SQL

var activities = db.UserActivity
                    .GroupBy(a => a.ActivityId, 
                             (k, g) => new { 
                                ActivityId = k, 
                                TotalPoints = g.Select(a => a.Points).sum() 
                            });

 var activitiesWithMostPoints = activities
                                .Where(a => a.TotalPoints == activities.Max(a => a.TotalPoints));

---

如果你只想要一个结果，即使有多个活动的分数最多

var activityWithMostPoints = db.UserActivity
                            .GroupBy(a => a.ActivityId, 
                                     (k, g) => new { 
                                        ActivityId = k, 
                                        TotalPoints = g.Select(a => a.Points).Sum() 
                                    })
                            .OrderByDescending(a => a.TotalPoints)
                            .First();

您提供的SQL查询实际上将返回所有具有最多点数的活动。这有点复杂，而且可能效率低下，这取决于生成的SQL

var activities = db.UserActivity
                    .GroupBy(a => a.ActivityId, 
                             (k, g) => new { 
                                ActivityId = k, 
                                TotalPoints = g.Select(a => a.Points).sum() 
                            });

 var activitiesWithMostPoints = activities
                                .Where(a => a.TotalPoints == activities.Max(a => a.TotalPoints));

---

如果你只想要一个结果，即使有多个活动的分数最多

var activityWithMostPoints = db.UserActivity
                            .GroupBy(a => a.ActivityId, 
                                     (k, g) => new { 
                                        ActivityId = k, 
                                        TotalPoints = g.Select(a => a.Points).Sum() 
                                    })
                            .OrderByDescending(a => a.TotalPoints)
                            .First();

您提供的SQL查询实际上将返回所有具有最多点数的活动。这有点复杂，而且可能效率低下，这取决于生成的SQL

var activities = db.UserActivity
                    .GroupBy(a => a.ActivityId, 
                             (k, g) => new { 
                                ActivityId = k, 
                                TotalPoints = g.Select(a => a.Points).sum() 
                            });

 var activitiesWithMostPoints = activities
                                .Where(a => a.TotalPoints == activities.Max(a => a.TotalPoints));

---

如果你只想要一个结果，即使有多个活动的分数最多

var activityWithMostPoints = db.UserActivity
                            .GroupBy(a => a.ActivityId, 
                                     (k, g) => new { 
                                        ActivityId = k, 
                                        TotalPoints = g.Select(a => a.Points).Sum() 
                                    })
                            .OrderByDescending(a => a.TotalPoints)
                            .First();

您提供的SQL查询实际上将返回所有具有最多点数的活动。这有点复杂，而且可能效率低下，这取决于生成的SQL

var activities = db.UserActivity
                    .GroupBy(a => a.ActivityId, 
                             (k, g) => new { 
                                ActivityId = k, 
                                TotalPoints = g.Select(a => a.Points).sum() 
                            });

 var activitiesWithMostPoints = activities
                                .Where(a => a.TotalPoints == activities.Max(a => a.TotalPoints));