C# LINQ to SQL-具有列表的自定义对象<；T>；财产

我试图做的是以下几点：

我有一个自定义对象OTest和OSubTest：

public class OTest
{
   public int TestId {get; set;}
   public List<OSubTest> SubTests {get; set;}
}

public class OSubTest
{
   public int SubTestId {get; set;}
}

问题是，如果LINQ不在数据的主查询中运行100个子查询，如何将“子测试”作为查询的一部分和主OTest对象中的列表属性获取

如果我这样做，那么它将对返回的每个记录执行一个查询，这不太实际：

var query = from t in Tests 
select new OTest
{
   TestId = t.TestId,
   SubTests = (from st in SubTests where st.TestId = t.TestId select new OSubTest{SubTestId = st.SubTestId}).ToList()
};

关于如何使用单个查询填充列表属性，您有什么想法吗？也许是左连接

任何帮助都将不胜感激

如果你需要任何澄清，请问我

编辑

好的，看看这个，当我有一个子列表时，它确实起作用，但一旦我添加第二个子列表，第二个子列表就会查询数据库100次。以下是我的确切疑问：

public List<OFile> GetFiles(int fileGroupId)
        {
            var query = (from f in CoreContext.Files
                         join fgf in CoreContext.FileGroupFiles on f.FileId equals fgf.FileId
                         where fgf.FileGroupId == fileGroupId
                         select new OFile
                                    {
                                        ActiveFile = f.ActiveFile,
                                        FileExtension = f.FileType,
                                        FileGuid = f.FileIdentifier,
                                        FileName = f.FileName,
                                        FilePath = f.FilePath,
                                        FileSize = f.FileSize,
                                        FileTitle = f.FileTitle,
                                        RevisionId = f.RevisionId,
                                        ParentFileId = f.ParentFileId,
                                        FileId = f.FileId,
                                        Attributes = f.FileAttributeFiles.Where(id => id.FileId == f.FileId).Select(
                                            id => new OFileAttribute
                                                      {
                                                          FileAttributeId = id.FileAttributeId,
                                                          Value = id.Value
                                                      }).ToList(),
                                        Tags = f.FileTags.Where(id => id.FileId == f.FileId).Select(
                                            id => new OFileTag
                                                      {
                                                          FileTagId = id.FileTagId,
                                                          TagName = id.TagName,
                                                      }).ToList(),


                                    });



            return query.ToList();
        }

public List GetFiles（int-fileGroupId）
{
var query=（来自CoreContext.Files中的f）
在CoreContext.FileGroupFiles中加入fgf。f.FileId等于fgf.FileId
其中fgf.FileGroupId==FileGroupId
选择新文件
{
ActiveFile=f.ActiveFile，
FileExtension=f.FileType，
FileGuid=f.FileIdentifier，
FileName=f.FileName，
FilePath=f.FilePath，
FileSize=f.FileSize，
FileTitle=f.FileTitle，
修订ID=f.修订ID，
ParentFileId=f.ParentFileId，
FileId=f.FileId，
Attributes=f.FileAttributeFileFiles.Where（id=>id.FileId==f.FileId）。选择(
id=>新的OFileAttribute
{
FileAttributeId=id.FileAttributeId，
Value=id.Value
}).ToList（），
Tags=f.FileTags.Where（id=>id.FileId==f.FileId）。选择(
id=>newofiletag
{
FileTagId=id.FileTagId，
标记名=id.TagName，
}).ToList（），
});
返回query.ToList（）；
}

这些属性将查询数据库100次，并且不会显示为联接

FileAttributeFiles表具有属性表的FK

谢谢

如果我这样做，那么它将对返回的每个记录执行一个查询，这不是很实用

嗯，真的吗？你试过了吗？我不确定

测试

和

子测试

应该是什么，但一般来说，LINQ to SQL执行以下形式的查询：

using (var c = new MyDataContext())
{
    var q = from t in c.Tests
            select new 
                   {
                       TestId = t.TestId,
                       SubTests = from st in t.SubTests 
                                  where st.TestId = t.TestId 
                                  select new 
                                  {
                                      SubTestId = st.SubTestId
                                  }
                    };
}

---

…在一个查询中。投影到POCO而不是匿名类型也能起作用。我不知道使用

ToList（）

是否会改变什么，因为我个人并不使用它；如果没有它，它“只能工作”。

是的，当我执行它并查看SQL profiler时，它为每个记录执行了一个子查询。我将再次检查我的查询，看看是否有不应该存在的内容。好的，一个子查询可以工作，但当我有两个子查询时，它会查询数据库100次。我用实际的查询更新了我的帖子。如果我一次单独运行一个属性，它会起作用，但是当我同时运行这两个属性时，属性将始终查询100次。想法？然后使用克雷格专利的LINQ调试算法™: 拿一个能用的箱子和一个不能用的箱子，一小块一小块地把它们转换成另一个。这将允许您缩小问题的范围。也许是

ToList（）

？不带那个试试？也许是两个子查询？在Northwind上尝试一个单独的测试用例。迟早你会发现确切的问题。我不认为是ToList（），我需要ToList（），因为我正在填充一个自定义对象。如果我单独使用每个子查询，它就会工作，但是，一旦我将它们都放在那里，就会发生这种情况。我会继续找，看看能不能找到答案。。。谢谢

using (var c = new MyDataContext())
{
    var q = from t in c.Tests
            select new 
                   {
                       TestId = t.TestId,
                       SubTests = from st in t.SubTests 
                                  where st.TestId = t.TestId 
                                  select new 
                                  {
                                      SubTestId = st.SubTestId
                                  }
                    };
}