Linq to SQL：多对多支持类

Question

我想要一个支持课程来帮助处理多对多关系。

正如我现在所看到的，它可能是一个双泛型类，您可以在围绕该关系的一个或两个实体部分类中定义。

让它允许访问另一个表而不必特别提及关系表应该很容易。然而，在集合中添加或删除有些棘手。您还必须在关系表中添加一行，并根据所做的事情提交或删除它。

这可以通过传递到这个泛型类的函数来完成吗？

是否存在这样的类，如果不存在，是否可以完成？

Answer 1

您可以创建一个可从多对多属性返回的 IManyToManySet 接口，并通过查询插入和实现 ManyToManySet 实现删除特征。

接口可能如下所示：

public interface IManyToManySet<TEntity> : IEnumerable<TEntity>
    where TEntity : class
{
    int Count { get; }
    void Add(TEntity entity);
    bool Remove(TEntity entity);
    void AddRange(IEnumerable<TEntity> collection);
}

实现可能如下所示：

public class ManyToManySet<TSource, TCross, TDestination>
    : IManyToManySet<TDestination>, IEnumerable<TDestination>
    where TDestination : class
    where TSource : class
    where TCross : class
{
    private TSource source;
    private EntitySet<TCross> crossSet;
    private Func<TCross, TDestination> destinationSelector;
    private Func<TSource, TDestination, TCross> crossFactory;

    public ManyToManySet(TSource source, 
        EntitySet<TCross> crossSet,
        Func<TCross, TDestination> destinationSelector,
        Func<TSource, TDestination, TCross> crossFactory)
    {
        this.source = source;
        this.crossSet = crossSet;
        this.destinationSelector = destinationSelector;
        this.crossFactory = crossFactory;
    }

    public int Count
    {
        get { return this.crossSet.Count; }
    }

    public void Add(TDestination entity)
    {
        var newEntity = this.crossFactory(this.source, entity);
        this.crossSet.Add(newEntity);
    }

    public bool Remove(TDestination entity)
    {
        var existingEntity = (
            from c in this.crossSet
            where this.destinationSelector(c) == entity
            select c)
            .SingleOrDefault();

        if (existingEntity != null)
        {
            return this.crossSet.Remove(existingEntity);
        }

        return false;
    }

    public void AddRange(IEnumerable<TDestination> collection)
    {
        foreach (var entity in collection)
        {
            this.Add(entity);
        }
    }

    public IEnumerator<TDestination> GetEnumerator()
    {
        return this.crossSet.Select(this.destinationSelector)
            .GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

您需要在此实现中提供一些内容：

1. TSource 实例，它指向定义属性的实体。
2. 指向定义交叉表的实体列表的 EntitySet。
3. 一个投影函数，允许您将 TCross 转换为 TDestination。
4. 一个工厂函数，允许您基于 TSource 和 TDestination 创建新的 TCross。

将其转换为实际示例（使用 Product 和 Order），将为您提供 Order 实体中的以下属性：

private IManyToManySet<Product> products;
public IManyToManySet<Product> Products
{
    get
    {
        if (this.products != null)
        {
            this.products = new ManyToManySet<Order, OrderProduct, Product>(
                this, this.OrderProducts, op => op.Product,
                (o, p) => new OrderProduct { Order = o, Product = p });
        }

        return this.products;
    }
}

以及以下属性： Product 实体：

private IManyToManySet<Order> orders;
public IManyToManySet<Order> Orders
{
    get
    {
        if (this.orders == null)
        {
            this.orders = new ManyToManySet<Product, OrderProduct, Order>(
                this, this.OrderProducts, op => op.Order,
                (p, o) => new OrderProduct { Order = o, Product = p });
        }

        return this.orders;
    }
}

IManyToManySet 接口实际上是多余的，因为您可以直接返回 ManyToMany 。然而，该接口隐藏了 TSource 和 TCross 类型参数，这使得该属性的用户更具可读性。

请注意，此实现与 LINQ to SQL 的 EntitySet具有相同的加载行为；使用时，它会将完整的对象集加载到内存中。就像在集合上使用 where 或 First 的 EntitySet 一样，仍然从数据库加载完整的集合。你需要意识到这一点。

然而，重要的区别在于 LINQ to SQL 理解 LINQ 查询中的 EntitySet属性。在 LINQ 查询中使用 IManyToManySet 将会严重失败。

我希望这有帮助。

Answer 2

在 LINQ to SQL 中创建一个感觉像本机的解决方案很困难（甚至不可能），因为这样的解决方案必须按以下方式工作：

1. 多个集合应该建模为其他多个实体的属性。
2. 它必须支持插入、更新和删除。
3. 它应该在编写 LINQ 查询时起作用。

第 1 点的解决方案很容易。以一个具有 Product 类的模型为例，该类与 Order 具有多对多关系。您可以在 Order 类上定义以下属性：

public IEnumerable<Product> Products
{
    get { return this.OrderProducts.Select(op => op.Product); }
}

但是，这不适用于第 2 点和第 3 点。虽然我们可以创建一个允许插入的通用集合，但 LINQ to SQL 将永远无法转换使用此属性返回 SQL 查询。例如，以下 LINQ 查询看起来很正常：

var bigOrders =
    from order in context.Orders
    where order.Products.Any(p => p.Price > 100)
    select order;

不幸的是，此查询将失败，因为 LINQ to SQL 不知道如何将 Products 属性映射到 SQL。

当您想要本机使用此功能时，您应该考虑迁移到实体框架（4.0 或更高版本）。 EF 本身支持此功能。