在这篇文章中，我们将带领您了解c#–LINQwithsubselect和groupby只能获取列表中每个项目的最新版本的全貌，包括c#listview获取指定列名的相关情况。同时，我们还将为您介绍有关
在这篇文章中，我们将带领您了解c# – LINQ with subselect和groupby只能获取列表中每个项目的最新版本的全貌，包括c# listview 获取指定列名的相关情况。同时，我们还将为您介绍有关addSelect 中的 laravel groupBy() 和 count()、as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别、C# LINQ GroupBy、C# linq 使用 Groupby lamda 获取非重复数据的知识，以帮助您更好地理解这个主题。
本文目录一览：- c# – LINQ with subselect和groupby只能获取列表中每个项目的最新版本（c# listview 获取指定列名）
- addSelect 中的 laravel groupBy() 和 count()
- as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别
- C# LINQ GroupBy
- C# linq 使用 Groupby lamda 获取非重复数据
c# – LINQ with subselect和groupby只能获取列表中每个项目的最新版本（c# listview 获取指定列名）
我有一个IEnumerable通用列表,其中包含不同版本的答案(每个都有一个FK的问题).从这个列表中我只需要获得最新版本的答案字典.
一个非常简化的类图：
题
-ID
-题
– …其他属性
回答
-ID
-版
-QuestionID
-值
– …其他属性
目前我已经得到以下几点：
IEnumerable<Answer> answers = GetAnswers();
IDictionary<long,AnswerDTO> latestVersionAnswers = new Dictionary<long,AnswerDTO>();
if (answers != null)
{
latestVersionAnswers = answers
.OrderBy(e => e.ID)
.GroupBy(e => e.Question.ID)
.Select(g => new AnswerDTO
{
Version = g.Last().Version,// g.Select(e => e.Version).Max(),QuestionID = g.Key,ID = g.Last().ID,Value = g.Last().Value
}).ToDictionary(c => c.QuestionID);
}
虽然这在很大程度上起作用,但您可以快速看到它需要一些严重的优化(并且有点脆弱,因为它取决于答案记录行顺序而不是“最大”逻辑).使用LINQ做什么最好的方式,或者最好是为每个循环做多个？
>如果我只需要版本(而不是ID,Value等),我不需要OrderBy,因为我可以去g.Select(e => e.Version).Max()(或我’现在已经看到了C# List<> GroupBy 2 Values的帖子,但是这又会返回key / s和一个属性：Version).
>最终,在这种特殊情况下,我更愿意只是“过滤”原始列表,并返回原始的答案而不是涉及到AnswerDTO.
任何指针或帮助将不胜感激！
解决方法
private void button1_Click(object sender,EventArgs e)
{
List<Answer> list = GetAnswers();
var dict = (from a in list
group a by a.QuestionID into grp
from g in grp
where g.Version == grp.Max(m => m.Version)
select new { id = g.QuestionID,q = g }).ToDictionary( o => o.id,o => o.q);
StringBuilder sb = new StringBuilder();
foreach (var elem in dict)
{
sb.AppendLine(elem.Key.ToString() + "-" + elem.Value.Version.ToString());
}
MessageBox.Show(sb.ToString());
}
private List<Answer> GetAnswers()
{
List<Answer> result = new List<Answer>();
result.Add(new Answer() { ID = 1,QuestionID = 1,Version = 1 });
result.Add(new Answer() { ID = 2,Version = 2 });
result.Add(new Answer() { ID = 3,Version = 3 });
result.Add(new Answer() { ID = 4,QuestionID = 2,Version = 1 });
result.Add(new Answer() { ID = 5,Version = 2 });
result.Add(new Answer() { ID = 6,Version = 3 });
result.Add(new Answer() { ID = 7,QuestionID = 3,Version = 1 });
result.Add(new Answer() { ID = 8,Version = 2 });
result.Add(new Answer() { ID = 9,Version = 3 });
result.Add(new Answer() { ID = 10,Version = 4 });
return result;
}
addSelect 中的 laravel groupBy() 和 count()
我已经解决了:)
$query->addSelect(['tire_set_count' =>
DeliveryNoteItem::selectRaw('count(distinct car_id)')
->whereColumn('delivery_note_items.delivery_note_id','delivery_notes.id'),]);
使用以下查询，它将解决您的问题：
$query->addSelect(['tire_set_count' =>
DeliveryNoteItem::selectRaw('count(*) AS result')
->whereColumn('delivery_note_items.delivery_note_id','=','delivery_notes.id')
->groupBy('car_id'),]);
as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别
编辑： 我在np.nan@ coldspeed，@ wen-ben，@
ALollz指出的字符串中犯的菜鸟错误。答案非常好，因此我不会删除此问题以保留这些答案。
原文：
我已经阅读了这个问题/答案[groupby.first（）和groupby.head（1）有什么区别？
该答案说明差异在于处理NaN价值上。但是，当我打电话给groupby时as_index=False，他们俩都选择了NaN。
此外，Pandas具有groupby.nth与和类似的功能head，并且first
有什么差异groupby.first(),groupby.nth(0),groupby.head(1)有as_index=False？
下面的例子：
In [448]: df
Out[448]:
A B
0 1 np.nan
1 1 4
2 1 14
3 2 8
4 2 19
5 2 12
In [449]: df.groupby('A',as_index=False).head(1)
Out[449]:
A B
0 1 np.nan
3 2 8
In [450]: df.groupby('A',as_index=False).first()
Out[450]:
A B
0 1 np.nan
1 2 8
In [451]: df.groupby('A',as_index=False).nth(0)
Out[451]:
A B
0 1 np.nan
3 2 8
我看到`firs（）’重置了索引，而其他2则没有。除此之外，还有什么区别吗？
C# LINQ GroupBy
一、先准备要使用的类：
1、Person类：
class Person { public string Name { set; get; } public int Age { set; get; } public string Gender { set; get; } public override string ToString() => Name; }
2、准备要使用的List，用于分组（GroupBy）：
List<Person> personList = new List<Person> { new Person { Name = "P1",Age = 18,Gender = "Male" },new Person { Name = "P2",Age = 19,Gender = "Male",},Age = 17,Gender = "Female",} };
二、第一种用法：
public static IEnumerable<IGrouping<TKey,TSource>> GroupBy<TSource,TKey>(this IEnumerable<TSource> source,Func<TSource,TKey> keySelector);
官方释义：根据指定的键选择器函数对序列中的元素进行分组。
我们要分组的集合为source，集合内每个元素的类型为TSource，这里第一个参数keySelector的类型为Func<TSource,TKey>，用于将TSource元素按照由此委托返回的类型TKey进行分组，结果为一个已分好组的集合（集合中的集合）。
编写客户端试验代码如下：
var groups = personList.GroupBy(p => p.Gender); foreach (var group in groups) { Console.WriteLine(group.Key); foreach(var person in group) { Console.WriteLine($"\t{person.Name},{person.Age}"); } }
以上代码指定的KeySelector是Person类的Gender属性，因此，以上会按照Gender（性别）进行分组，我们使用两个嵌套的foreach循环将分组的内容打印到控制台。
因为groups返回的类型为IEnumerable<IGouping<TKey,TSource>>，因此以上返回的类型为IEnumerable<IGouping<string,Person>>。
IGouping<string,Person>是已经分组后的集合，内部集合元素为Person，且IGouping有一个Key属性，类型为string（指的是Gender属性类型），用于分组的标识。
输出结果如下：
其等价的LINQ语句为：
var groups = from p in personList group p by p.Gender;
以上的意思可以这样理解：从personList取出p，并对p进行分组，使用分组的依据（Key）为p.Gender，并将分组的结果存储到pGroup，并将分组的结果选择出来合并成一个集合。
三、第二种用法：
public static IEnumerable<IGrouping<TKey,TKey> keySelector,IEqualityComparer<TKey> comparer);
官方释义：根据指定的键选择器函数对序列中的元素进行分组，并使用指定的比较器对键进行比较。
这种比第一种方法多了一个参数，那就是一个相等比较器，目的是为了当TKey为自定义的类时，GroupBy能根据TKey指定的类根据相等比较器进行分组，
因此，自定义类如何进行分组，GroupBy是不知道的，需要自己定义自己的相等比较器。
首先，将personList更改如下（下划线部分）：
List<Person> personList = new List<Person> { new Person { Name = "P1",new Person { Name = "P1",new Person { Name = "P3",} };
其次，增加一个相等比较器类，用于对Person进行分组：
class PersonEqualityComparer : IEqualityComparer<Person> { public bool Equals(Person x,Person y) => x.Name == y.Name; public int GetHashCode(Person obj) => obj.Name.GetHashCode(); }
其中定义了如何对一个Person相等性定义，只要实现IEqualityComparer<Person>即可，这里以Name作为Person类是否相同的依据。
最后，现在我们对Person类进行分组，编写客户端实验代码如下：
var groups = personList.GroupBy(p => p,new PersonEqualityComparer()); foreach (var group in groups) { Console.WriteLine(group.Key.ToString()); foreach(var person in group) { Console.WriteLine($"\t{person.Age},{person.Gender}"); } }
以上的分组依据是Person类，并运用了自己定义的Person类相同比较器，只要Name相同，就分为一组，
输出结果如下：
四、第三种用法：
public static IEnumerable<IGrouping<TKey,TElement>> GroupBy<TSource,TKey,TElement>(this IEnumerable<TSource> source,TElement> elementSelector);
官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且通过使用指定的函数对每个组中的元素进行投影。
这个比第一种用法多了一个elementSelector，第一种用法是对集合本身按照TKey分组，并将自己（TSource）添加到分组内，而当前的用法则可以选择自己想要添加到分组内的元素类型。
编写客户端实验代码如下：
var groups = personList.GroupBy(p => p.Gender,p=>p.Name); foreach (var group in groups) { Console.WriteLine(group.Key.ToString()); foreach(var name in group) { Console.WriteLine($"\t{name}"); } }
以上代码是按照p.Gender进行分组，并将p.Name作为组内的元素。
输出结果如下：
其等价的LINQ语句为：
var groups = from p in personList group p.Name by p.Gender;
五、第四种用法：
public static IEnumerable<TResult> GroupBy<TSource,TResult>(this IEnumerable<TSource> source,Func<TKey,IEnumerable<TSource>,TResult> resultSelector);
官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。
这个跟之前的用法都不同，之前的用法都是将结果进行分组，并返回IGrouping<TKey,TSource>对象，而当前用法则是返回自己定义的类型（TResult），在返回自己定义类型之前，将会传入两个参数，一个是TKey，为分组时指定的对象，另外一个则是IEnumerable<TSource>，为分组后的内部对象集合。
编写客户端实验代码如下：
string GetPersonInfo(string gender,IEnumerable<Person> persons) { string result = $"{gender}:\t"; foreach (var p in persons) { result += $"{p.Name},{p.Age}\t"; } return result; } var results = personList.GroupBy(p => p.Gender,(g,ps) => GetPersonInfo(g,ps)); foreach (var result in results) { Console.WriteLine(result); }
GetPersonInfo为局部方法，见于C#7.0及以上。
以上代码将分组后的内容（一个是TKey，为p.Gender，另外一个是IEnumerable<TSource>，为IEnumerable<Person>）作为字符串输出，因此，将返回的类型为字符串集合。
输出结果如下：
其等价的LINQ语句为：
var results = from p in personList group p by p.Gender into pGroup select GetPersonInfo(pGroup.Key,pGroup);
六、第五种用法：
public static IEnumerable<IGrouping<TKey,TElement> elementSelector,IEqualityComparer<TKey> comparer);
官方释义：根据键选择器函数对序列中的元素进行分组。通过使用比较器对键进行比较，并且通过使用指定的函数对每个组的元素进行投影。
与第三种用法基本相同，只是多了一个相等比较器，用于分组的依据。
使用第二种用法的personList及PersonEqualityComparer，编写客户端实验代码如下：
var groups = personList.GroupBy(p => p,p => new { p.Age,p.Gender },new PersonEqualityComparer()); foreach (var group in groups) { Console.WriteLine(group.Key.ToString()); foreach (var name in group) { Console.WriteLine($"\t{name.Age},{name.Gender}"); } }
以上代码的分组依据是Person，PersonEqualityComparer则是作为Person分组的比较器，每个组内为一个匿名类型集合。
输出结果如下：
七、第六种用法：
public static IEnumerable<TResult> GroupBy<TSource,TResult> resultSelector,IEqualityComparer<TKey> comparer);
官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。通过使用指定的比较器对键进行比较。
与第四种用法基本相同，只是多了一个相等比较器，用于分组的依据。
使用第二种用法的personList及PersonEqualityComparer，编写客户端实验代码如下：
string GetPersonInfo(Person person,IEnumerable<Person> persons) { string result = $"{person.ToString()}:\t"; foreach (var p in persons) { result += $"{p.Age},{p.Gender}\t"; } return result; } var results = personList.GroupBy(p => p,(p,ps) => GetPersonInfo(p,ps),new PersonEqualityComparer()); foreach (var result in results) { Console.WriteLine(result); }
以上代码的分组依据是Person，PersonEqualityComparer则是作为Person分组的比较器，每个组内为一个Person集合，并将返回类型为string的字符串输出。
输出结果如下：
八、第七种用法：
public static IEnumerable<TResult> GroupBy<TSource,TElement,IEnumerable<TElement>,TResult> resultSelector);
官方释义：根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。通过使用指定的函数对每个组的元素进行投影。
与第四种方法很类似，只是对分组内的元素进行选择，原有为TSource，现改为TElement。
编写客户端实验代码如下：
string GetPersonInfo(string gender,IEnumerable<string> names) { string result = $"{gender}:\t"; foreach (var name in names) { result += $"{name}\t"; } return result; } var results = personList.GroupBy(p => p.Gender,(p=>p.Name),ns) => GetPersonInfo(g,ns)); foreach (var result in results) { Console.WriteLine(result); }
以上代码将使用Gender分组，并将分组后的信息组合成一条字符串，并输出到控制台。
输出结果如下：
九、第八种用法：
public static IEnumerable<TResult> GroupBy<TSource,IEqualityComparer<TKey> comparer);
官方释义： 根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。通过使用指定的比较器对键值进行比较，并且通过使用指定的函数对每个组的元素进行投影。
与第七种用法基本相同，只是多了一个相等比较器，用于分组的依据。
使用第二种用法的personList及PersonEqualityComparer，编写客户端实验代码如下：
var results = personList.GroupBy(p => p,(p=>new { p.Age,p.Gender}),ns) => { string result = $"{p.ToString()}:\t"; foreach (var n in ns) { result += $"{n.Age},{p.Gender}\t"; } return result; },new PersonEqualityComparer()); foreach (var result in results) { Console.WriteLine(result); }
以上代码将使用Person分组，使用Person比较器作为分组的依据，并将分组后的信息组合成一条字符串，并输出到控制台。
输出结果如下：
C# linq 使用 Groupby lamda 获取非重复数据
var bookkeeperlist = await db.Bookkeeper.Where(a => a.AgentUserId == userId && a.ServiceItem == 1).GroupBy(b => b.BasicUserId).Select(a => new MyServicesListViewModel()
{
HeadIcon = apiUrl + a.FirstOrDefault(m => m.BasicUserId == a.Key).Basic_User.HeadIcon,
UserName = a.FirstOrDefault(m => m.BasicUserId == a.Key).Basic_User.RealName,
Mobile = a.FirstOrDefault(m => m.BasicUserId == a.Key).Basic_User.Mobile,
DepartmentName = a.FirstOrDefault(m => m.BasicUserId == a.Key).Basic_User.Sys_Department.FullName,
CompanyName = a.FirstOrDefault(m => m.BasicUserId == a.Key).Agent_Company.CompanyName,
FlowName = a.FirstOrDefault(m => m.BasicUserId == a.Key).Agent_Bill.Agent_Flow.FlowName,
ServiceItem = a.FirstOrDefault(m => m.BasicUserId == a.Key).ServiceItem
}).ToListAsync();
return bookkeeperlist;
今天关于c# – LINQ with subselect和groupby只能获取列表中每个项目的最新版本和c# listview 获取指定列名的介绍到此结束，谢谢您的阅读，有关addSelect 中的 laravel groupBy() 和 count()、as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别、C# LINQ GroupBy、C# linq 使用 Groupby lamda 获取非重复数据等更多相关知识的信息可以在本站进行查询。
本文标签：
