Dapper 中多重映射的正确使用

Question

我正在尝试使用 Dapper 的多重映射功能返回 ProductItems 和关联客户的列表。

[Table("Product")]
public class ProductItem
{
    public decimal ProductID { get; set; }        
    public string ProductName { get; set; }
    public string AccountOpened { get; set; }
    public Customer Customer { get; set; }
} 

public class Customer
{
    public decimal CustomerId { get; set; }
    public string CustomerName { get; set; }
}

我的 Dapper 代码：

var sql = @"select * from Product p 
            inner join Customer c on p.CustomerId = c.CustomerId 
            order by p.ProductName";

var data = con.Query<ProductItem, Customer, ProductItem>(
    sql,
    (productItem, customer) => {
        productItem.Customer = customer;
        return productItem;
    },
    splitOn: "CustomerId,CustomerName"
);

这工作正常，但我似乎必须将完整的列列表添加到“splitOn”参数中才能返回所有客户的属性。如果我不添加“CustomerName”，它将返回 null。我是否误解了多重映射功能的核心功能？我不想每次都添加完整的列名称列表。

Answer 1

我刚刚运行了一个运行良好的测试：

var sql = "select cast(1 as decimal) ProductId, 'a' ProductName, 'x' AccountOpened, cast(1 as decimal) CustomerId, 'name' CustomerName";

var item = connection.Query<ProductItem, Customer, ProductItem>(sql,
    (p, c) => { p.Customer = c; return p; }, splitOn: "CustomerId").First();

item.Customer.CustomerId.IsEqualTo(1);

需要将 splitOn 参数指定为分割点，它默认为 Id。如果有多个分割点，您需要将它们添加到逗号分隔的列表中。

假设您的记录集如下所示：

ProductID | ProductName | AccountOpened | CustomerId | CustomerName 
---------------------------------------   -------------------------

Dapper 需要知道如何按此顺序将列拆分为 2 个对象。粗略一看，客户从 CustomerId 列开始，因此 splitOn: CustomerId。

这里有一个大警告，如果基础表中的列顺序由于某种原因翻转：

ProductID | ProductName | AccountOpened | CustomerName | CustomerId  
---------------------------------------   -------------------------

splitOn: CustomerId 将导致空客户名称。

如果您指定 CustomerId,CustomerName 作为分割点，dapper 会假设您尝试将结果集分割为 3 个对象。第一个从头开始，第二个从 CustomerId 开始，第三个从 CustomerName 开始。

Answer 2

我们的表的命名与您的表类似，其中类似“CustomerID”的内容可能会使用“select *”操作返回两次。因此，Dapper 正在完成其工作，但分割得太早（可能），因为列将是：

(select * might return):
ProductID,
ProductName,
CustomerID, --first CustomerID
AccountOpened,
CustomerID, --second CustomerID,
CustomerName.

这使得 splitOn: 参数不太有用，特别是当您不确定返回列的顺序时。可以手动指定列...但现在是 2017 年了，我们很少再为基本对象获取这样做了。

我们所做的就是简单地使用 Id 的别名，并且从不指定 splitOn（使用 Dapper 的默认“Id”），而且多年来它对数千个查询都非常有效。

select 
p.*,

c.CustomerID AS Id,
c.*

...瞧！默认情况下，Dapper 只会根据 Id 进行拆分，并且该 Id 出现在所有 Customer 列之前。当然，它会向您的返回结果集中添加一个额外的列，但是对于准确了解哪些列属于哪个对象的附加实用程序来说，这是极小的开销。您可以轻松扩展它。需要地址和国家信息？

select
p.*,

c.CustomerID AS Id,
c.*,

address.AddressID AS Id,
address.*,

country.CountryID AS Id,
country.*

最重要的是，您可以用最少量的 SQL 清楚地显示哪些列与哪个对象关联。剩下的由 Dapper 完成。

Answer 3

假设以下结构，其中“|”是分裂点，Ts 是应应用映射的实体。

       TFirst         TSecond         TThird           TFourth
------------------+-------------+-------------------+------------
col_1 col_2 col_3 | col_n col_m | col_A col_B col_C | col_9 col_8
------------------+-------------+-------------------+------------

以下是您必须编写的 Dapper 查询。

Query<TFirst, TSecond, TThird, TFourth, TResut> (
    sql : query,
    map: Func<TFirst, TSecond, TThird, TFourth, TResult> func,
    parma: optional,
    splitOn: "col_3, col_n, col_A, col_9")

因此，我们希望 TFirst 映射到 col_1 col_2 col_3，TSecond 映射到 col_n col_m ...

splitOn 表达式转换为：

开始将所有列映射到 TFirst 直到找到名为或别名为“col_3”的列，并且还包括“ col_3' 进入映射结果。

然后开始映射到 TSecond 从“col_n”开始的所有列，并继续映射直到找到新的分隔符（在本例中为“col_A”），并标记 TThird 映射的开始，依此类推。

SQL 查询的列和映射对象的 props 是 1:1 关系（意味着它们应该命名相同）。如果 SQL 查询生成的列名不同，您可以使用“AS [Some_Alias_Name]”表达式为它们设置别名。

Answer 4

如果您需要映射一个大型实体，那么编写每个字段一定是一项艰巨的任务。

我尝试了 @BlackjacketMack 答案，但我的一个表有一个 Id 列，其他表没有（我知道这是数据库设计问题，但是......）然后这会在 dapper 上插入一个额外的分割，这就是为什么

select
p.*,

c.CustomerID AS Id,
c.*,

address.AddressID AS Id,
address.*,

country.CountryID AS Id,
country.*

对我不起作用。然后我对此进行了一些更改，只需插入一个名称与表上的任何字段都不匹配的分割点，在可能的情况下将 as Id 更改为 as _SplitPoint_，最终的sql脚本如下所示：

select
p.*,

c.CustomerID AS _SplitPoint_,
c.*,

address.AddressID AS _SplitPoint_,
address.*,

country.CountryID AS _SplitPoint_,
country.*

然后在dapper中添加一个splitOn，如下所示

cmd =
    "SELECT Materials.*, " +
    "   Product.ItemtId as _SplitPoint_," +
    "   Product.*, " +
    "   MeasureUnit.IntIdUM as _SplitPoint_, " +
    "   MeasureUnit.* " +
    "FROM   Materials INNER JOIN " +
    "   Product ON Materials.ItemtId = Product.ItemtId INNER JOIN " +
    "   MeasureUnit ON Materials.IntIdUM = MeasureUnit.IntIdUM " +
List < Materials> fTecnica3 = (await dpCx.QueryAsync<Materials>(
        cmd,
        new[] { typeof(Materials), typeof(Product), typeof(MeasureUnit) },
        (objects) =>
        {
            Materials mat = (Materials)objects[0];
            mat.Product = (Product)objects[1];
            mat.MeasureUnit = (MeasureUnit)objects[2];
            return mat;
        },
        splitOn: "_SplitPoint_"
    )).ToList();

Answer 5

还有一个警告。如果 CustomerId 字段为 null（通常在具有左连接的查询中），Dapper 将创建 Customer = null 的 ProductItem。在上面的例子中：

var sql = "select cast(1 as decimal) ProductId, 'a' ProductName, 'x' AccountOpened, cast(null as decimal) CustomerId, 'n' CustomerName";
var item = connection.Query<ProductItem, Customer, ProductItem>(sql, (p, c) => { p.Customer = c; return p; }, splitOn: "CustomerId").First();
Debug.Assert(item.Customer == null); 

甚至还有一个警告/陷阱。如果您没有映射 splitOn 中指定的字段，并且该字段包含 null，Dapper 将创建并填充相关对象（在本例中为 Customer）。为了演示如何将此类与之前的 sql 一起使用：

public class Customer
{
    //public decimal CustomerId { get; set; }
    public string CustomerName { get; set; }
}
...
Debug.Assert(item.Customer != null);
Debug.Assert(item.Customer.CustomerName == "n");  

Answer 6

我通常在我的存储库中执行此操作，对我的用例很有用。我想我会分享。也许有人会进一步扩展这一点。

一些缺点是：

• 这假设您的外键属性是子对象的名称+“Id”，例如UnitId。
• 我只将 1 个子对象映射到父对象。

代码：

    public IEnumerable<TParent> GetParentChild<TParent, TChild>()
    {
        var sql = string.Format(@"select * from {0} p 
        inner join {1} c on p.{1}Id = c.Id", 
        typeof(TParent).Name, typeof(TChild).Name);

        Debug.WriteLine(sql);

        var data = _con.Query<TParent, TChild, TParent>(
            sql,
            (p, c) =>
            {
                p.GetType().GetProperty(typeof (TChild).Name).SetValue(p, c);
                return p;
            },
            splitOn: typeof(TChild).Name + "Id");

        return data;
    }

Answer 7

我想指出一个非常重要的方面：实体中的属性名称必须与选择语句匹配。 splitOn 的另一个方面是默认情况下它如何查找 Id，因此您不必指定它，除非您的命名类似于 CustomerId，而不是 Id。让我们看看这 2 种方法：

方法 1

Entity Customer : Id Name

您的查询应该类似于：

SELECT c.Id as nameof{Customer.Id}, c.Foo As nameof{Customer.Name}.

然后您的映射了解实体和表之间的关系。

方法 2

实体客户：CustomerId、FancyName
选择c.Id作为nameof{Customer.CustomerId}，c.WeirdAssName作为nameof{Customer.FancyName}
在映射的最后，您必须使用 SplitOn 指定 Id 为 CustomerId。

我遇到了一个问题，即使映射在技术上是正确的，但由于与 SQL 语句不匹配，我无法获取值。