C# 使用EntityFramework从联接返回新对象

我有点被困在这里了。 我得到了一个数据库，其中包含项目表和这些项目的版本：

public class Project
{
    public int Id { get; set; }

    public string Name { get; set; }
    public string Type { get; set; }

    public List<ProjectVersion> Versions { get; set; } = new List<ProjectVersion>();

    public Project() { }
}

如何获取具有所需版本的项目

更新

多亏了@RomanoZumbé和@Maritim的想法，我才能解决这个问题。问题在于模型的不同类别

using ( var ctx = new DatabaseContext() )
{
    var query = 
            ctx.Projects
                .Include(p => p.Versions)
                .Where(p => p.Id.Equals(projectId))
                .Select( p =>
                    new Project()
                    {
                        Id       = p.Id,
                        Name     = p.Name,
                        Type     = p.Type,
                        Versions = 
                            p.Versions
                                .Where( v => v.Version.Equals(version))
                                .Select( v =>
                                    new ProjectVersion()
                                    {
                                        Checksum    = v.Checksum,
                                        Description = v.Description,
                                        EntryPoints = 
                                            v.EntryPoints
                                                .Select( e => new EntryPoint()
                                                {           
                                                    Call = e.Call,                                                                                          
                                                    Step = e.Step                                                                                       
                                                })                                                                                  
                                                .ToList()   
                                    })
                                    .ToList()
                    })
                    .Select(x => x);

                var result = query.ToList();

                return result[0];
}

---

我不知道我是否理解正确，这是我的想法，但我认为如果使用Include（…）语句会更容易。由于已经包含了项目“版本”（相当于数据库中的JOIN语句），因此可以执行以下操作：

var query = 
        ctx.Projects
            .Include(p => p.Versions)
            .Where(p => p.Id.Equals(projectId))
            .Select(
                new Project
                {
                    Name     = p.Name,
                    Type     = p.Type,
                    Id       = p.Id,                                
                    Versions = p.Versions.Where(v => v.Version.Equals(version))
                });

return query.FirstOrDefault();

---

我不完全确定这是否是你想要实现的，但也许这会有所帮助

            var res = (from p in ctx.Projects
                       let v = ctx.Versions.FirstOrDefault(x => p.Versions.Any(v => v.Id == x.Id))
                       where p.Id == projectId
                    select new Project
                    {
                        Name = p.Name,
                        Type = p.Type,
                        Id = p.Id,
                        Versions = new List<ProjectVersion>()
                        {
                            new ProjectVersion
                            {
                                Checksum    = v.Checksum,
                                Description = v.Description,
                                Version     = v.Version ,
                                EntryPoints = new List<EntryPoint>(v.EntryPoints),
                                Systems     = new List<System>(v.Systems)
                            }
                        }
                    });

            return res.FirstOrDefault()

var res=（来自ctx.Projects中的p
设v=ctx.Versions.FirstOrDefault（x=>p.Versions.Any（v=>v.Id==x.Id））
其中p.Id==projectd
选择新项目
{
名称=p.名称，
类型=p.类型，
Id=p.Id，
版本=新列表（）
{
新项目版本
{
校验和=v.校验和，
描述，
版本=v.版本，
入口点=新列表（v.入口点），
系统=新列表（v.Systems）
}
}
});
return res.FirstOrDefault（）

您是否只是在

新列表后面缺少
（）
？如果您查询.AsEnumerable（），然后尝试访问第一个匹配项，会发生什么情况？@RomanoZumbé我在这里使用集合初始化器，请参阅@Maritim Tred it，现在它说“LINQtoEntities中只支持无参数构造函数和初始值设定项。”@Ben我不知道，你可以不加括号，然后在回答问题时，请务必指出OP方法不起作用的原因。啊，是的，我对这东西不熟悉：-）可以。哦，当然！有道理，我会这样做：）这会产生同样的结果。Project.Versions和DB中的Versions的数据类型不同，因此我使用
p.Versions.Where（v=>v.Version.Equals（Version））。选择（v=>new ProjectVersion（）{Id=v.Id…}）。SingleOrDefault（）
您不能使用同一个类吗？我不知道他们是不同的班级。如果您需要一些模型映射源，请尝试首先使用db类获取数据，然后映射到您想要的模型，也许这样会更好？
Cannot create a query result of type 'System.Collections.Generic.List`1[UserQuery+ProjectVersion]'.

using ( var ctx = new DatabaseContext() )
{
    var query = 
            ctx.Projects
                .Include(p => p.Versions)
                .Where(p => p.Id.Equals(projectId))
                .Select( p =>
                    new Project()
                    {
                        Id       = p.Id,
                        Name     = p.Name,
                        Type     = p.Type,
                        Versions = 
                            p.Versions
                                .Where( v => v.Version.Equals(version))
                                .Select( v =>
                                    new ProjectVersion()
                                    {
                                        Checksum    = v.Checksum,
                                        Description = v.Description,
                                        EntryPoints = 
                                            v.EntryPoints
                                                .Select( e => new EntryPoint()
                                                {           
                                                    Call = e.Call,                                                                                          
                                                    Step = e.Step                                                                                       
                                                })                                                                                  
                                                .ToList()   
                                    })
                                    .ToList()
                    })
                    .Select(x => x);

                var result = query.ToList();

                return result[0];
}

var query = 
        ctx.Projects
            .Include(p => p.Versions)
            .Where(p => p.Id.Equals(projectId))
            .Select(
                new Project
                {
                    Name     = p.Name,
                    Type     = p.Type,
                    Id       = p.Id,                                
                    Versions = p.Versions.Where(v => v.Version.Equals(version))
                });

return query.FirstOrDefault();

            var res = (from p in ctx.Projects
                       let v = ctx.Versions.FirstOrDefault(x => p.Versions.Any(v => v.Id == x.Id))
                       where p.Id == projectId
                    select new Project
                    {
                        Name = p.Name,
                        Type = p.Type,
                        Id = p.Id,
                        Versions = new List<ProjectVersion>()
                        {
                            new ProjectVersion
                            {
                                Checksum    = v.Checksum,
                                Description = v.Description,
                                Version     = v.Version ,
                                EntryPoints = new List<EntryPoint>(v.EntryPoints),
                                Systems     = new List<System>(v.Systems)
                            }
                        }
                    });

            return res.FirstOrDefault()