如何使用FluentMap进行一对多映射？

在使用FluentMap进行一对多映射时，你可以利用FluentMap的配置功能来定义复杂的映射关系。FluentMap是一个用于简化对象映射的库，通常与Dapper等ORM工具一起使用。以下是一个示例，展示了如何使用FluentMap进行一对多映射。

安装FluentMap

首先，确保你已经安装了FluentMap和Dapper：

dotnet add package Dapper
dotnet add package Dapper.FluentMap
dotnet add package Dapper.FluentMap.Dommel

示例代码

假设你有两个实体：Order和OrderItem，一个订单可以包含多个订单项。

数据库表结构

CREATE TABLE Orders (
    OrderId INT PRIMARY KEY,
    OrderDate DATETIME
);

CREATE TABLE OrderItems (
    OrderItemId INT PRIMARY KEY,
    OrderId INT,
    ProductName NVARCHAR(100),
    Quantity INT,
    FOREIGN KEY (OrderId) REFERENCES Orders(OrderId)
);

实体类

public class Order
{
    public int OrderId { get; set; }
    public DateTime OrderDate { get; set; }
    public List<OrderItem> OrderItems { get; set; } = new List<OrderItem>();
}

public class OrderItem
{
    public int OrderItemId { get; set; }
    public int OrderId { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
}

FluentMap配置

using Dapper.FluentMap;
using Dapper.FluentMap.Dommel;
using Dapper.FluentMap.Mapping;

public class OrderMap : EntityMap<Order>
{
    public OrderMap()
    {
        Map(o => o.OrderId).ToColumn("OrderId");
        Map(o => o.OrderDate).ToColumn("OrderDate");
    }
}

public class OrderItemMap : EntityMap<OrderItem>
{
    public OrderItemMap()
    {
        Map(oi => oi.OrderItemId).ToColumn("OrderItemId");
        Map(oi => oi.OrderId).ToColumn("OrderId");
        Map(oi => oi.ProductName).ToColumn("ProductName");
        Map(oi => oi.Quantity).ToColumn("Quantity");
    }
}

public static class FluentMapperInitializer
{
    public static void Initialize()
    {
        FluentMapper.Initialize(config =>
        {
            config.AddMap(new OrderMap());
            config.AddMap(new OrderItemMap());
            config.ForDommel();
        });
    }
}

数据库查询和映射

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using Dapper;

public class Program
{
    public static void Main()
    {
        FluentMapperInitializer.Initialize();

        using (var connection = new SqlConnection("YourConnectionString"))
        {
            var sql = @"
                SELECT * FROM Orders o
                LEFT JOIN OrderItems oi ON o.OrderId = oi.OrderId";

            var orderDictionary = new Dictionary<int, Order>();

            var orders = connection.Query<Order, OrderItem, Order>(
                sql,
                (order, orderItem) =>
                {
                    if (!orderDictionary.TryGetValue(order.OrderId, out var currentOrder))
                    {
                        currentOrder = order;
                        orderDictionary.Add(currentOrder.OrderId, currentOrder);
                    }

                    currentOrder.OrderItems.Add(orderItem);
                    return currentOrder;
                },
                splitOn: "OrderItemId"
            ).Distinct().ToList();

            foreach (var order in orders)
            {
                Console.WriteLine($"Order ID: {order.OrderId}, Order Date: {order.OrderDate}");
                foreach (var item in order.OrderItems)
                {
                    Console.WriteLine($"  Order Item ID: {item.OrderItemId}, Product: {item.ProductName}, Quantity: {item.Quantity}");
                }
            }
        }
    }
}

解释

实体类：定义了Order和OrderItem类，Order类包含一个OrderItems列表，用于存储一对多关系的订单项。
FluentMap配置：使用EntityMap类为Order和OrderItem类创建映射配置，并在FluentMapperInitializer类中初始化映射。
数据库查询和映射：使用Dapper的Query方法执行SQL查询，并通过委托将查询结果映射到Order和OrderItem对象。使用Dictionary来确保每个订单只被添加一次，并将订单项添加到相应的订单中。