在C#中，如何根据对象中的属性对集合进行排序？

我有一个Person对象集合，一个人可以属于多个团队

public class Person
{
     public List<string> Teams();
} 

或者，我可以通过这样做得到一个独特的团队列表：

   var teams = people.SelectMany(r=>r.Teams);

   var teams = people.SelectMany(r=>r.Teams).Distinct(new TeamComparer());

但我现在想进入前十名

按最常用的方法对团队进行排序的正确方法是什么？例如，如果我有

  var person = new Person(){Teams = new List<string>{"Team A", "Team D"} }
  var person2 = new Person(){Teams = new List<string>{"Team B", "Team C"} }
  var person3 = new Person(){Teams = new List<string>{"Team B", "Team C"} }
  var person4 = new Person(){Teams = new List<string>{"Team B", "Team D"} }

var person=new person（）{Teams=new List{“Team A”，“Team D”}
var person2=newperson（）{Teams=newlist{“teamb”，“teamc”}
var person3=newperson（）{Teams=newlist{“teamb”，“teamc”}
var person4=newperson（）{Teams=newlist{“teamb”，“teamd”}

因此，在上面的示例中，它将按顺序返回：

B队
C队
D队
团队A

列出lstpeople=GetPeople（）；
lstPerson=lstPerson.OrderBy（x=>x.personID.toList（）；
lstPerson=lstPerson.orderbydescending（x=>x.personID.toList（）；

列出lstpeons=GetPeople（）；
lstPerson=lstPerson.OrderBy（x=>x.personID.toList（）；
lstPerson=lstPerson.orderbydescending（x=>x.personID.toList（）；

列出lstpeons=GetPeople（）；
lstPerson=lstPerson.OrderBy（x=>x.personID.toList（）；
lstPerson=lstPerson.orderbydescending（x=>x.personID.toList（）；

列出lstpeons=GetPeople（）；
lstPerson=lstPerson.OrderBy（x=>x.personID.toList（）；
lstPerson=lstPerson.orderbydescending（x=>x.personID.toList（）；

如果您想获得使用率最高的十个团队，您应该对他们进行分组，而不是使用

Distinct（）

消除重复项。一旦有了分组，按分组数排序，然后取前十个，如下所示：

var topTen = people
    .SelectMany(r => r.Teams)          // Get the teams with duplicates
    .GroupBy(t => t)                   // Group by team
    .OrderByDescending(g => g.Count()) // Sort by count
    .Take(10)                          // Take top ten
    .Select(g => g.Key)                // Drop groups
    .ToList();                         // Make a list

---

如果您想获得使用率最高的十个团队，您应该对它们进行分组，而不是使用

Distinct（）

消除重复项。一旦有了分组，按分组数排序，然后取前十个，如下所示：

var topTen = people
    .SelectMany(r => r.Teams)          // Get the teams with duplicates
    .GroupBy(t => t)                   // Group by team
    .OrderByDescending(g => g.Count()) // Sort by count
    .Take(10)                          // Take top ten
    .Select(g => g.Key)                // Drop groups
    .ToList();                         // Make a list

---

如果您想获得使用率最高的十个团队，您应该对它们进行分组，而不是使用

Distinct（）

消除重复项。一旦有了分组，按分组数排序，然后取前十个，如下所示：

var topTen = people
    .SelectMany(r => r.Teams)          // Get the teams with duplicates
    .GroupBy(t => t)                   // Group by team
    .OrderByDescending(g => g.Count()) // Sort by count
    .Take(10)                          // Take top ten
    .Select(g => g.Key)                // Drop groups
    .ToList();                         // Make a list

---

如果您想获得使用率最高的十个团队，您应该对它们进行分组，而不是使用

Distinct（）

消除重复项。一旦有了分组，按分组数排序，然后取前十个，如下所示：

var topTen = people
    .SelectMany(r => r.Teams)          // Get the teams with duplicates
    .GroupBy(t => t)                   // Group by team
    .OrderByDescending(g => g.Count()) // Sort by count
    .Take(10)                          // Take top ten
    .Select(g => g.Key)                // Drop groups
    .ToList();                         // Make a list

---

你所说的最常用是什么意思？扩展方法应该做你的问题标题所要求的…根据你的编辑，我同意@dasblinkenlight的答案。你所说的最常用是什么意思？扩展方法应该做你的问题标题所要求的…根据你的编辑，我会选择@dasblinkenlight的答案。你所说的最常用是什么意思？扩展方法应该满足你的问题标题的要求…根据你的编辑，我会选择@dasblinkenlight的答案。你所说的最常用是什么意思？扩展方法应该满足你的问题标题的要求…根据你的编辑，我同意@dasblinkenlight的答案。

toList

是无效的C。它应该是

ToList（）

ToList

是无效的C。它应该是

ToList（）

ToList

是无效的C。它应该是

ToList（）

ToList

是无效的C。它应该是

ToList（）

。我唯一要做的就是将select改为：

。select（g=>new{team=g.Key，count=g.count（）}）

这样他也可以看到计数，但另一方面我唯一要做的就是将select改为：

。select（g=>new{team=g.Key，count=g.count（）}）

这样他也可以看到计数，但另一方面，我唯一要做的就是将select改为：

.select（g=>new{team=g.Key，count=g.count（）}）

这样他也可以看到计数，但另一方面，我唯一要做的就是将select改为：

.select（g=>new{team=g.Key，count=g.count（）}）

这样他也可以看到计数，但其他方面很好