我真的很喜欢 Dapper 的简单性和可能性。我想使用 Dapper 来解决我日常面临的常见挑战。这些在下面描述。

这是我的简单模型。

public class OrderItem {
    public long Id { get; set; }
    public Item Item { get; set; }
    public Vendor Vendor { get; set; }
    public Money PurchasePrice { get; set; }
    public Money SellingPrice { get; set; }
}

public class Item
{
    public long Id { get; set; }
    public string Title { get; set; }
    public Category Category { get; set; }
}

public class Category
{
    public long Id { get; set; }
    public string Title { get; set; }
    public long? CategoryId { get; set; }
}

public class Vendor
{
    public long Id { get; set; }
    public string Title { get; set; }
    public Money Balance { get; set; }
    public string SyncValue { get; set; }
}

public struct Money
{
    public string Currency { get; set; }
    public double Amount { get; set; }
}

有两个挑战一直困扰着我。

问题 1: 当我只有一个属性差异或简单的枚举/结构映射时，我是否应该始终在 DTO 实体之间创建一个具有映射逻辑的 DTO？

例如:我的 Vendor 实体具有 Balance 属性作为 struct(否则它可能是 Enum)。我还没有找到比该解决方案更好的方法:

public async Task<Vendor> Load(long id) {
    const string query = @"
        select * from [dbo].[Vendor] where [Id] = @id
    ";

    var row = (await this._db.QueryAsync<LoadVendorRow>(query, new {id})).FirstOrDefault();
    if (row == null) {
        return null;
    }

    return row.Map();
}

在这个方法中，我有 2 个开销代码: 1. 我必须创建 LoadVendorRow 作为 DTO 对象； 2. 我必须自己编写 LoadVendorRow 和 Vendor 之间的映射:

public static class VendorMapper {
    public static Vendor Map(this LoadVendorRow row) {
        return new Vendor {
            Id = row.Id,
            Title = row.Title,
            Balance = new Money() {Amount = row.Balance, Currency = "RUR"},
            SyncValue = row.SyncValue
        };
    }
}

也许你可能会建议我必须将金额和货币存储在一起并像 _db.QueryAsync<Vendor, Money, Vendor>(...) 一样检索它- 也许，你是对的。在那种情况下，如果我需要存储/检索 Enum(OrderStatus 属性)，我该怎么办？

var order = new Order
{
    Id = row.Id,
    ExternalOrderId = row.ExternalOrderId,
    CustomerFullName = row.CustomerFullName,
    CustomerAddress = row.CustomerAddress,
    CustomerPhone = row.CustomerPhone,
    Note = row.Note,
    CreatedAtUtc = row.CreatedAtUtc,
    DeliveryPrice = row.DeliveryPrice.ToMoney(),
    OrderStatus = EnumExtensions.ParseEnum<OrderStatus>(row.OrderStatus)
};

我能否在没有自己的实现的情况下完成这项工作并节省时间？

问题 2: 如果我想将数据恢复到比简单的单级 DTO 稍微复杂一点的实体，我该怎么办？ OrderItem 是一个很好的例子。这是我现在用来检索它的技术:

public async Task<IList<OrderItem>> Load(long orderId) {
    const string query = @"
            select [oi].*,
                   [i].*,
                   [v].*,
                   [c].*
              from [dbo].[OrderItem] [oi]
              join [dbo].[Item] [i]
                on [oi].[ItemId] = [i].[Id]
              join [dbo].[Category] [c]
                on [i].[CategoryId] = [c].[Id]
              join [dbo].[Vendor] [v]
                on [oi].[VendorId] = [v].[Id]
             where [oi].[OrderId] = @orderId
    ";

    var rows = (await this._db.QueryAsync<LoadOrderItemRow, LoadItemRow, LoadVendorRow, LoadCategoryRow, OrderItem>(query, this.Map, new { orderId }));

    return rows.ToList();
}

如您所见，我的问题 1 问题迫使我为层次结构中的每个实体编写自定义映射器和 DTO。那是我的映射器:

private OrderItem Map(LoadOrderItemRow row, LoadItemRow item, LoadVendorRow vendor, LoadCategoryRow category) {
    return new OrderItem {
        Id = row.Id,
        Item = item.Map(category),
        Vendor = vendor.Map(),
        PurchasePrice = row.PurchasePrice.ToMoney(),
        SellingPrice = row.SellingPrice.ToMoney()
    };
}

我想消除许多映射器以防止不必要的工作。

最佳答案

Is there a clean way to retrive & map Order entity with relative properties like Vendor, Item, Category etc)

您没有显示您的 Order 实体，但我将以您的 OrderItem 为例，向您展示您不需要针对特定​​问题的映射工具(如引用)。您可以通过执行以下操作检索 OrderItem 以及每个的 Item 和 Vendor 信息:

var sql = @"
select oi.*, i.*, v.* 
from OrderItem 
    inner join Item i on i.Id = oi.ItemId
    left join Vendor v on v.Id = oi.VendorId
    left join Category c on c.Id = i.CategoryId";
var items = connection.Query<OrderItem, Item, Vendor, Category, OrderItem>(sql, 
    (oi,i,v,c)=>
    {
      oi.Item=i;oi.Item.Category=c;oi.Vendor=v;
      oi.Vendor.Balance = new Money { Amount = v.Amount, Currency = v.Currency};
      return oi; 
    });

注意:使用left join，并根据您的表结构进行相应调整。

关于c# - Dapper:映射层次结构和单一不同的属性，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31999144/