简洁的一对多关系映射

Question

我正在尝试与 dapper 映射一对多关系。但我无法让它发挥作用。

我有一个表 order 和另一个表 order_product 产品 order_product

现在我有以下代码：

var sql = @"SELECT 
* 
FROM `order` o
INNER JOIN `order_product` op ON op.order_id = o.order_id
WHERE o.order_id = 5153";
var products = await connection.QueryAsync<Order, OrderProduct, Order>(sql, (order, product) =>
{
    if (order.Products == null)
    {
        order.Products = new List<OrderProduct>();
    }

    if (product != null)
    {
        order.Products.Add(product);
    }

    return order;
}, splitOn: "order_id");

出于测试目的，我正在加载 id 5153 的订单，其中包含 4 个产品。

OrderProduct 类定义为：

public class OrderProduct
    {
        public int order_product_id { get; set; }
        public int order_id { get; set; }
        public int product_id { get; set; }
        public string name { get; set; }
        public string model { get; set; }
        public int quantity { get; set; }
        public decimal price { get; set; }
        public decimal total { get; set; }
        public decimal tax { get; set; }
        public int reward { get; set; }
    }

订单类保存订单表中的所有属性 +

public ICollection<OrderProduct> Products { get; set; } 

但是，我得到的是 4 个 Order 对象，其中每个对象包含 4 个 Order 对象，而不是 1 个 Order 对象和 4 个 OrderProduct 对象。

有谁知道我在这里做错了什么？

Answer 1

尝试这种方式：

        var sql = @"SELECT * FROM `order` o 
              INNER JOIN `order_product` op ON op.order_id = o.order_id
            WHERE o.order_id = 5153";
        var orderDictionary = new Dictionary<int, Order>();
        var products = await connection.QueryAsync<Order, OrderProduct, Order>(sql, (order, product) =>
        {
            if (!orderDictionary.TryGetValue(order.order_id, out Order docEntry))
            {
                docEntry = order;
                docEntry.Products = new List<OrderProduct>();
                orderDictionary.Add(docEntry.order_id, docEntry);
            }

            if (product != null) docEntry.Products.Add(product);
            docEntry.Products = docEntry.Products.Distinct().ToList();

            return docEntry;
        }
        , splitOn: "order_id");

您在 orderDictionary 上获得了订单列表，如果您只想要一个列表，请以这种方式获取

var orderList = orderDictionary.Values.ToList();

select * 对于生产查询来说是一个坏主意，您需要确保您的 order_id 列是 splitOn 列，并且您有其中两个，通常 Dapper 会完成他的工作并尝试猜测哪一个是分离器，但如果你通过别名其中一个来修复它会更好

Answer 2

这就是关联的表示方式：

public class Tag
{
    public int TagId { get; set; }
    public string TagName { get; set; }
    public List<Post> Posts { get; set; }
}
public class Post
{
    public int PostId { get; set; }
    public string Headline { get; set; }
    public string Content { get; set; }
    public Author Author { get; set; }
    public List<Tag> Tags { get; set; } 
}

您使用多重映射以与之前相同的方式填充两个实体，但这次，您对结果使用分组函数来组合重复的帖子实例和标签：

using(var connection = new SqlConnection(connectionString))
{
var sql = @"SELECT p.PostId, Headline, t.TagId, TagName
            FROM Posts p 
            INNER JOIN PostTags pt ON pt.PostId = p.PostId
            INNER JOIN Tags t ON t.TagId = pt.TagId";
            
var posts = await connection.QueryAsync<Post, Tag, Post>(sql, (post, tag) 
=> {
    post.Tags.Add(tag);
    return post;
}, splitOn: "TagId");

var result = posts.GroupBy(p => p.PostId).Select(g =>
{
    var groupedPost = g.First();
    groupedPost.Tags = g.Select(p => p.Tags.Single()).ToList();
    return groupedPost;
});

foreach(var post in result)
{
    Console.Write($"{post.Headline}: ");
    
    foreach(var tag in post.Tags)
    {
        Console.Write($" {tag.TagName} ");
    }
    
    Console.Write(Environment.NewLine);
    }
}