将Linq查询结果映射到DTO类

Question

我想使用EF从数据库获取记录并将值分配给DTO类。请考虑Linq查询的以下表格。

表A，表B，表C

对于每个表A记录有TableB中多条记录。对于每个TableB记录，TableC中有多个记录。 现在我的DTO的这个样子

public class TableA_DTO 
{ 
    public int tableA_rowid { get; set; } 
    //remaining tableA field definitions 

    public List<TableB_DTO> TableB_records { get; set; } 
} 

public class TableB_DTO 
{ 
    public int tableB_rowid { get; set; } 
    //remaining tableB field definitions 

    public List<TableC_DTO> TableC_records { get; set; } 
} 

public class TableC_DTO 
{ 
    public int tableC_rowid { get; set; } 
    //remaining tableC field definitions 
} 

我的LINQ查询看起来查询结果是这样的

var qry = from ent in TableA 
      select ent; 

在我的映射类我遍历项目，像这样：

foreach (var dataitem in query) 
    { 
     TableA_DTO dto = new TableA_DTO(); 
     dto.tableA_rowid = dataitem.ID; 
     //remaining field definitions here 
    } 

现在这适用于TableA中的所有字段，它从数据库中提取一条记录，并为表TableA中的每个字段在TableA_DTO中设置所需的属性。我还希望在TableA属性字段中通过名称TableB_records填充TableB属性字段中的所有匹配记录，并且还在TableB_DTO中填充TableB_DTO属性中TableC的所有匹配记录名称TableC_records

可以这样做吗？我需要改变什么？难道LINQ查询或我做我的映射

感谢您的时间的方式......

Answer 1

我会将您的DTO从List更改为IEnumerable，而不是在LINQ查询中做所有事情。

var query = 
    from ent in TableA 
    select new TableA_DTO 
    { 
     TableAProperty = a.Property, 
     TableB_records = 
      from b in TableB 
      where ent.Key == b.Key 
      select new TableB_DTO 
      { 
       TableBProperty = b.Property, 
       TableC_records = 
        from c in TableC 
        where b.Key == c.Key 
        select new TableC_DTO 
        { 
         TableCProperty = c.Property 
        } 
      } 
    }; 

Answer 2

我会做一个工厂方法，即：TableA_DTO CreateDTO(TableAItem item);

利用这一点，你可以只重写查询as：

IEnumerable<TableA_DTO> = TableA.AsEnumerable().Select(CreateDTO); 

这会直接给你“DTO”对象的集合。这就是说，如果你使用的是实体框架，在这种情况下，在最近版本中添加的EF Code First可能更有用。

Answer 3

首先，我只需要问你是否可以使用Entity Framework 4.1和POCOs（DbContext）并避免使用DTO的altoghther？

假设答案是否定的，那肯定是因为你没有拉回所有的字段，或者你在某种程度上改变了数据的“形状”。

在这种情况下，你可以改变你的LINQ查询看起来是这样的：

from t in table 
where ... 
select new DTOA() 
{ 
    TheDtoProperty = theTableProperty, 
    AndSoOn = AndSoOn 
}; 

做这种方式的好处：如果你打开SQL事件探查器，你应该看到，仅列那您请求将其转换为实际的SQL查询。如果您先查询所有列，然后拉取值，则所有列将被拉下线。

Answer 4

UPDATE

正如其他指出的，平坦化的结果（如下所示）与实体框架4.0工作时是不需要的，因为它可以LINQ查询就转化为一种有效的扁平的结果您。因此，只有在使用LINQ to SQL（或其他可能的其他LINQ提供程序）时才需要以下代码。请注意，我只用EF over SQL Server进行了测试，而不是通过Oracle进行了测试，因为这种行为可能是LINQ提供程序特定的，这意味着Oracle提供商（仍处于测试阶段）或商业Devart提供商可能仍然在执行N + 1.

---

你要做的是得到一组结构像树的对象。如果没有特别的注意，你会触发对数据库的许多查询。有一层嵌套，你会触发 N + 1查询，但由于你的嵌套是两层深，你将触发 M×（N + 1）+ 1查询，这几乎肯定会对性能（不管你的数据集的大小是多少）。你想要的是确保只有一个查询发送到数据库。为了确保这一点，您必须创建一个中间查询来平滑结果，就像您在旧SQL日期中所做的那样，可以检索树状数据:-)。 看看下面的例子：

var records = 
    from record in db.TableC 
    where ... // any filtering can be done here 
    select record; 

// important to call ToArray. This ensures that the flatterned result 
// is pulled in one single SQL query. 
var results = (
    from c in records 
    select new 
    { 
     tableA_rowid = c.B.A.Id, 
     tableA_Prop1 = c.B.A.Property1, 
     tableA_Prop2 = c.B.A.Property2, 
     tableA_PropN = c.B.A.PropertyN, 
     tableB_rowid = c.B.Id, 
     tableB_Property1 = c.B.Property1, 
     tableB_Property2 = c.B.Property2, 
     tableB_PropertyN = c.B.PropertyN, 
     tableC_rowid = c.Id, 
     tableC_Property1 = c.Property1, 
     tableC_Property2 = c.Property2, 
     tableC_PropertyN = c.PropertyN, 
    }) 
    .ToArray(); 

下一步是进行改造，在内存中的数据结构（使用匿名类型）转换成DTO的树结构对象：

// translate the results to DTO tree structure 
TableA_DTO[] dtos = (
    from aresult in results 
    group aresult by aresult.tableA_rowid into group_a 
    let a = group_a.First() 
    select new TableA_DTO 
    { 
     tableA_rowid = a.tableA_rowid, 
     tableA_Prop1 = a.tableA_Prop1, 
     tableA_Prop2 = a.tableA_Prop2, 
     TableB_records = (
      from bresult in group_a 
      group bresult by bresult.tableB_rowid into group_b 
      let b = group_b.First() 
      select new TableB_DTO 
      { 
       tableB_rowid = b.tableB_rowid, 
       tableB_Prop1 = b.tableB_Prop1, 
       tableB_Prop2 = b.tableB_Prop2, 
       TableC_records = (
        from c in group_b 
        select new TableC_DTO 
        { 
         tableC_rowid = c.tableC_rowid, 
         tableC_Prop1 = c.tableC_Prop1, 
         tableC_Prop2 = c.tableC_Prop2, 
        }).ToList(), 
      }).ToList() 
    }) 
    .ToArray(); 

作为你可以看到，解决方案的第一部分实际上是这样做的'旧'方式，当我们仍然手工编写我们的SQL查询时，这种方式就回来了。不过很好，一旦我们得到这种类型的内存数据集，我们可以再次利用LINQ（to Objects）来获取我们想要的结构中的这些数据。

请注意，这也可以让你做分页和排序。这会有点棘手，但肯定不是不可能的。