C# 在EntityFramework中按Take和Group进行分组

我需要从对话中获取（例如，2），2条消息

Id | messageId | Message
---|-----------|--------
1  | 1         | "asd"
1  | 2         | "asd2"
1  | 3         | "asd3"
1  | 4         | "asd4"
2  | 5         | "asd5"
3  | 6         | "asd6"
3  | 7         | "asd7"
3  | 8         | "asd8"
3  | 9         | "asd9"
3  | 10        | "asd10"
4  | 11        | "asd11"
4  | 12        | "asd12"
4  | 13        | "asd13"

例如：

id=idConversation

Id | messageId | Message
---|-----------|--------
1  | 1         | "asd"
1  | 2         | "asd2"
1  | 3         | "asd3"
1  | 4         | "asd4"
2  | 5         | "asd5"
3  | 6         | "asd6"
3  | 7         | "asd7"
3  | 8         | "asd8"
3  | 9         | "asd9"
3  | 10        | "asd10"
4  | 11        | "asd11"
4  | 12        | "asd12"
4  | 13        | "asd13"

我想要这个

Id   messageId   Message
---|-----------|--------
1  | 1         | "asd"
1  | 2         | "asd2"
2  | 5         | "asd5"
3  | 6         | "asd6"
3  | 7         | "asd7"
4  | 11        | "asd11"
4  | 12        | "asd12"

我可以在对话中发牢骚，但我不能限制在对话中发牢骚的数量

var test = unitOfWork.ChatMensagemRepository.GetAll()
                  .Where(x => x.PessoaCodigoPessoa == codigoRemetente)
                  .GroupBy(x => x.ChatConversaCodigoChatConversa)
                  .Select(group => new
                  {
                      codigoChat = group.Key,
                      list = group.Select(mensagem => new
                      {
                          // do stuff
                      })
                  }).ToList();

这没关系。。。但是，当我分组时，不要限制我的列表。采取（2）。选择。。。。。 给我“子查询返回超过1行”

错误：子查询返回的行数超过1行

var test = unitOfWork.ChatMensagemRepository.GetAll()
                  .Where(x => x.PessoaCodigoPessoa == codigoRemetente)
                  .GroupBy(x => x.ChatConversaCodigoChatConversa)
                  .Select(group => new
                  {
                      codigoChat = group.Key,
                      list = group.Take(2).Select(mensagem => new
                      {
                          // do stuff
                      })
                  }).ToList();

var test = unitOfWork.ChatMensagemRepository.GetAll()
                  .Where(x => x.PessoaCodigoPessoa == codigoRemetente)
                  .GroupBy(x => x.ChatConversaCodigoChatConversa)
                  .Select(group => new
                  {
                      codigoChat = group.Key,
                      list = group.Select(mensagem => new
                      {
                          // do stuff
                      }).take(2)
                  }).ToList();

---

错误：子查询返回超过1行

，下面是一个我认为您所追求的示例。此查询将按GPA返回每个类中的前3个sudtents：

var test = unitOfWork.ChatMensagemRepository.GetAll()
                  .Where(x => x.PessoaCodigoPessoa == codigoRemetente)
                  .GroupBy(x => x.ChatConversaCodigoChatConversa)
                  .Select(group => new
                  {
                      codigoChat = group.Key,
                      list = group.Take(2).Select(mensagem => new
                      {
                          // do stuff
                      })
                  }).ToList();

var test = unitOfWork.ChatMensagemRepository.GetAll()
                  .Where(x => x.PessoaCodigoPessoa == codigoRemetente)
                  .GroupBy(x => x.ChatConversaCodigoChatConversa)
                  .Select(group => new
                  {
                      codigoChat = group.Key,
                      list = group.Select(mensagem => new
                      {
                          // do stuff
                      }).take(2)
                  }).ToList();

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Ef6Test
{

    class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public string Class{ get; set; }

        public decimal GPA { get; set; }
    }

    class Db : DbContext
    {
        public DbSet<Student> Students { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            using (var db = new Db())
            {
                var q = db.Students
                         .GroupBy(s => s.Class)
                         .SelectMany(g => g.OrderByDescending(s => s.GPA).Take(3));

                Console.WriteLine(q.ToString());

                Console.ReadKey();
            }

        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Data.Entity；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
命名空间Ef6Test
{
班级学生
{
公共int Id{get；set；}
公共字符串名称{get；set；}
公共字符串类{get；set；}
公共十进制GPA{get；set；}
}
类Db:DbContext
{
公共数据库集学生{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
使用（var db=new db（））
{
var q=db.学生
.GroupBy（s=>s.Class）
.SelectMany（g=>g.OrderByDescending（s=>s.GPA）.Take（3））；
Console.WriteLine（q.ToString（））；
Console.ReadKey（）；
}
}
}
}

我尝试了此代码，效果良好：

class Conversation
{
    public int Id;
    public string Message;
    public int MessageId;
}

class Program
{

    static void Main(string[] args)
    {
        var inputList = new List<Conversation>
        {
            new Conversation() {Id = 1, Message = "asd0", MessageId = 1},
            new Conversation() {Id = 1, Message = "asd1", MessageId = 2},
            new Conversation() {Id = 1, Message = "asd2", MessageId = 3},
            new Conversation() {Id = 2, Message = "asd3", MessageId = 4},
            new Conversation() {Id = 2, Message = "asd4", MessageId = 5},
            new Conversation() {Id = 2, Message = "asd5", MessageId = 6},
            new Conversation() {Id = 3, Message = "asd6", MessageId = 7}
        };

        var outputList = inputList.GroupBy(x => x.Id)
            .SelectMany(x => x.OrderBy(y => y.MessageId).Take(2).ToList())
            .ToList();

        Console.ReadKey();
    }
}

课堂对话
{
公共int Id；
公共字符串消息；
公共int-MessageId；
}
班级计划
{
静态void Main（字符串[]参数）
{
var inputList=新列表
{
新建对话（）{Id=1，Message=“asd0”，MessageId=1}，
新建对话（）{Id=1，Message=“asd1”，MessageId=2}，
新建对话（）{Id=1，Message=“asd2”，MessageId=3}，
新建对话（）{Id=2，Message=“asd3”，MessageId=4}，
新建对话（）{Id=2，Message=“asd4”，MessageId=5}，
新建对话（）{Id=2，Message=“asd5”，MessageId=6}，
新建对话（）{Id=3，Message=“asd6”，MessageId=7}
};
var outputList=inputList.GroupBy（x=>x.Id）
.SelectMany（x=>x.OrderBy（y=>y.MessageId）.Take（2.ToList（））
.ToList（）；
Console.ReadKey（）；
}
}

也许让我们看看你能做些什么，你如何决定组中谁是不允许和其他人一起玩的坏孩子！我将显示，一分钟编辑：当我将.take（number）放在mensagens上时，我得到消息“null reference.”string您可以使用子查询从组中获取最多N行来解决此问题。搜索基于sql的解决方案可能会有所帮助。如果使用

SelectMany

可以将列表平铺为适当项的集合+InnerException{“Subquery返回多行”}System.Exception{MySql.Data.MySqlClient.MySqlException}@AntonioHenrique I更新了answer@Mhd不工作，我用更多的例子更新了我的问题+InnerException{“子查询返回超过1行”}System.Exception{MySql.Data.MySqlClient.MySqlException}我不知道。该查询模式适用于SQL Server。