Linq to sql 将linq到sql视图结果映射到实体-如何更改GROUPBY子句？

假设我有一个非常简单的db图：

以及它的一个视图：

 create view vTraining
as
select t.Id as TrainingId,t.[Status]  , 
t.[User], t.Title,t.Organisation,t.[Month],t.[Year], 
s.Id as SubjectId, s.Name as SubjectName,
c.Text as Comment
from Training t
join Subject s on s.Training = t.Id
join Comment c on c.Training = t.Id

使用示例数据：

正如你所看到的，这是一个包含三个主题的单一培训。 我想通过linq到sql将此结果映射到此结构：

public class ViewModel
    {
        public string Comment { set; get; }
        public List<Item> Trainings { set; get; }
    }

    public class Item
    {
        public int TrainingId { set; get; }
        public int User { set; get; }
        public int Status { set; get; }
        public string Title { set; get; }
        public string Organisation { set; get; }
        public int? Month { set; get; }
        public int Year { set; get; }
        public List<KeyValuePair<int, string>> Subjects { set; get; }
    }

公共类视图模型
{
公共字符串注释{set；get；}
公共列表{set；get；}
}
公共类项目
{
public int TrainingId{set；get；}
公共int用户{set；get；}
公共int状态{set；get；}
公共字符串标题{set；get；}
公共字符串组织{set；get；}
公共整数？月{set；get；}
公共整数年{set；get；}
公共列表主题{set；get；}
}

这是我创建的查询：

 var data = (from training in dc.vTrainings
                            group training by new
                           {
                               training.TrainingId,
                               training.Status,
                               training.Month,
                               training.Organisation,
                               training.Title
                           }
                                into g
                                select new ViewModel()
                                {
                                    Comment = g.Select(x =>
                                    x.Comment).First(),
                                    Trainings = g.Select(
                                     x => new Item()
                                     {
                                         Month = x.Month,
                                         Organisation = x.Organisation,
                                         Title = x.Title,
                                         Year = x.Year,
                                         Subjects = g.Select(
                                         z => new KeyValuePair<int, string>(z.SubjectId, z.SubjectName)).ToList()
                                     }).ToList()

                                })//.GroupBy(x => x.Trainings).Select(x => x.Key)
                                    .ToList();

var数据=（来自dc.vTrainings培训
新员工集体培训
{
training.TrainingId，
培训、地位，
培训，一个月，
培训、组织、，
培训、职称
}
进入g
选择新建ViewModel（）
{
注释=g.Select（x=>
x、 注释），
培训=g.选择(
x=>newitem（）
{
月=x.月，
组织=x.组织，
Title=x.Title，
年份=x.年，
主题=g.选择(
z=>newkeyValuePair（z.SubjectId，z.SubjectName））.ToList（）
})托利斯先生（）
})//.GroupBy（x=>x.Key）。选择（x=>x.Key）
.ToList（）；

不幸的是，我得到的结果不是我想要的：

ViewModel对象仅创建一个ok对象，但对于每个单独的主题，都会创建一个新项目（应该是一个）。“主题”列表已正确创建。我试着创建第二组，通过，和其他一些事情，但这是我现在能得到的最好的结果。 如何编写此查询以获取一个ViewModel对象，该对象具有一个包含三个主题的Item对象？

尝试以下操作：

            var trainings =
                dc.vTrainings
                    .GroupBy(
                        t => new
                        {
                            t.TrainingId,
                            t.Status,
                            t.Month,
                            t.Organisation,
                            t.Title,
                            t.User,
                            t.Year
                        },
                        t =>
                        new
                        {
                            t.SubjectId,
                            t.SubjectName
                        })
                    .ToList()
                    .Select(
                        t =>
                            new Item
                            {
                                TrainingId = t.Key.TrainingId,
                                Status = t.Key.Status,
                                Month = t.Key.Month,
                                Organisation = t.Key.Organisation,
                                Title = t.Key.Title,
                                User = t.Key.User,
                                Year = t.Key.Year,
                                Subjects =
                                    t.Select(s => new KeyValuePair<int,string>(s.SubjectId,s.SubjectName)).ToList()
                            });

var训练=
直流电压
.群比(
t=>new
{
t、 培训ID，
t、 地位，
t、 月，
t、 组织，
t、 头衔，
t、 用户，
t、 年
},
t=>
新的
{
t、 主观性，
t、 主题名
})
托利斯先生（）
.选择(
t=>
新项目
{
培训ID=t.Key.TrainingId，
状态=t.Key.Status，
月份=t.Key.Month，
组织=t.Key.organization，
Title=t.Key.Title，
User=t.Key.User，
年份=t.Key.Year，
科目=
t、 选择（s=>newkeyvaluepair（s.SubjectId，s.SubjectName））.ToList（）
});

我终于得到了正确的结果：

var data = (from g in
                                (from training in dc.vTrainings
                                 where training.Status ==1
                                 group training
                                 by new
                                {
                                    training.TrainingId,
                                    training.Status,
                                    training.Month,
                                    training.Organisation,
                                    training.Title
                                }
                                     into g
                                     select g).AsEnumerable()

                            select new ViewModel()
                            {
                                Comment = g.Select(x =>
                                x.Comment).FirstOrDefault(),
                                Trainings = g.GroupBy(x => x.Status).Select(
                                 x => new Item()
                                 {
                                     Month = g.Key.Month,
                                     Organisation = g.Key.Organisation,
                                     Title = g.Key.Title,
                                     Subjects = (from i in g select new KeyValuePair<int, string>(i.SubjectId, i.SubjectName)).ToList()
                                 }).ToList()
                            }).ToList();

var数据=（从g开始）
（来自dc.V培训）
其中training.Status==1
团体训练
由新
{
training.TrainingId，
培训、地位，
培训，一个月，
培训、组织、，
培训、职称
}
进入g
选择g）.AsEnumerable（）
选择新建ViewModel（）
{
注释=g.Select（x=>
x、 注释）。FirstOrDefault（），
Trainings=g.GroupBy（x=>x.Status）。选择(
x=>newitem（）
{
月份=g.Key.Month，
组织=g.Key.Organization，
Title=g.Key.Title，
Subjects=（从i-in-g选择新的键值对（i.SubjectId，i.SubjectName））.ToList（）
})托利斯先生（）
}).ToList（）；

此查询仅适用于一次培训，但对我来说这不是问题，因为我按最新状态筛选它。我仍然很好奇如何为不止一次的训练编写它