我可以隐藏我的 ICollection当我仅在 EF4 代码中进行一对多映射时，字段如何？

Question

我的具有一对多映射的域类通常采用以下形式（未经测试的代码）：

public Customer Customer
{
    // Public methods.

    public Order AddOrder(Order order)
    {
        _orders.Add(order);
    }

    public Order GetOrder(long id)
    {
        return _orders.Where(x => x.Id).Single();
    }

    // etc.

    // Private fields.

    private ICollection<Order> _orders = new List<Order>();
}

纯 EF4 代码示例 我见过在处理一对多关系时公开公共 ICollection。

有没有办法通过公开来保存和恢复我的收藏？如果没有，我的领域对象将被设计为满足 ORM 的要求，这似乎违背了我们的努力精神。公开 ICollection（及其 Add 等方法）似乎不是特别干净，也不是我的默认方法。

更新

发现

Answer 1

我发现无论做什么，EF 都要求将 ICollection 公开。我认为这是因为当从数据库加载对象时，映射会查找集合属性，获取集合，然后调用集合的 Add 方法来添加每个子对象。

我想确保添加是通过父对象上的方法完成的，因此创建了一个包装集合、捕获添加并将其定向到我首选的添加方法的解决方案。

无法扩展 List 和其他集合类型，因为 Add 方法不是虚拟的。一种选择是扩展 Collection 类并重写 InsertItem 方法。

我只关注了 ICollection 接口的 Add、Remove 和 Clear 函数，因为是可以修改集合的。

首先，是我的基本集合包装器，它实现了 ICollection接口
默认行为是普通集合的行为。但是，调用者可以指定要调用的替代 Add 方法。此外，调用者可以通过将替代项设置为 null 来强制不允许进行 Add、Remove、Clear 操作代码>.如果有人尝试使用该方法，这会导致引发 NotSupportedException。

抛出异常不如从一开始就阻止访问。但是，应该对代码进行测试（单元测试），并且会很快发现异常并进行适当的代码更改。

public abstract class WrappedCollectionBase<T> : ICollection<T>
{

    private ICollection<T> InnerCollection { get { return GetWrappedCollection(); } }

    private Action<T> addItemFunction;
    private Func<T, bool> removeItemFunction;
    private Action clearFunction;


    /// <summary>
    /// Default behaviour is to be like a normal collection
    /// </summary>
    public WrappedCollectionBase()
    {
        this.addItemFunction = this.AddToInnerCollection;
        this.removeItemFunction = this.RemoveFromInnerCollection;
        this.clearFunction = this.ClearInnerCollection;
    }

    public WrappedCollectionBase(Action<T> addItemFunction, Func<T, bool> removeItemFunction, Action clearFunction) : this()
    {
        this.addItemFunction = addItemFunction;
        this.removeItemFunction = removeItemFunction;
        this.clearFunction = clearFunction;
    }

    protected abstract ICollection<T> GetWrappedCollection();

    public void Add(T item)
    {
        if (this.addItemFunction != null)
        {
            this.addItemFunction(item);
        }
        else
        {
            throw new NotSupportedException("Direct addition to this collection is not permitted");
        }
    }

    public void AddToInnerCollection(T item)
    {
        this.InnerCollection.Add(item);
    }

    public bool Remove(T item)
    {
        if (removeItemFunction != null)
        {
            return removeItemFunction(item);
        }
        else
        {
            throw new NotSupportedException("Direct removal from this collection is not permitted");
        }
    }

    public bool RemoveFromInnerCollection(T item)
    {
        return this.InnerCollection.Remove(item);
    }

    public void Clear()
    {
        if (this.clearFunction != null)
        {
            this.clearFunction();
        }
        else
        {
            throw new NotSupportedException("Clearing of this collection is not permitted");
        }
    }

    public void ClearInnerCollection()
    {
        this.InnerCollection.Clear();
    }

    public bool Contains(T item)
    {
        return InnerCollection.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        InnerCollection.CopyTo(array, arrayIndex);
    }

    public int Count
    {
        get { return InnerCollection.Count; }
    }

    public bool IsReadOnly
    {
        get { return ((ICollection<T>)this.InnerCollection).IsReadOnly; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return InnerCollection.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return InnerCollection.GetEnumerator();
    }

}

鉴于该基类，我们可以通过两种方式使用它。示例是使用原始的 post 对象。

1) 创建特定类型的包装集合（例如List）
公共类 WrappedListCollection ：WrappedCollectionBase、IList
{
私有列表innerList；

    public WrappedListCollection(Action<T> addItemFunction, Func<T, bool> removeItemFunction, Action clearFunction)
        : base(addItemFunction, removeItemFunction, clearFunction)
    { 
    this.innerList = new List<T>();
    }

    protected override ICollection<T> GetWrappedCollection()
    {
        return this.innerList;
    }
 <...snip....> // fill in implementation of IList if important or don't implement IList
    }

然后可以使用它：

 public Customer Customer
 {
 public ICollection<Order> Orders {get { return _orders; } }
 // Public methods.

 public void AddOrder(Order order)
 {
    _orders.AddToInnerCollection(order);
 }

// Private fields.

private WrappedListCollection<Order> _orders = new WrappedListCollection<Order>(this.AddOrder, null, null);
}

2) 给出一个要包装的集合，

 public class WrappedCollection<T> : WrappedCollectionBase<T>
{
    private ICollection<T> wrappedCollection;

    public WrappedCollection(ICollection<T> collectionToWrap, Action<T> addItemFunction, Func<T, bool> removeItemFunction, Action clearFunction)
        : base(addItemFunction, removeItemFunction, clearFunction)
    {
        this.wrappedCollection = collectionToWrap;
    }

    protected override ICollection<T> GetWrappedCollection()
    {
        return this.wrappedCollection;
    }
}

可以使用它，如下所示：

{
公共 ICollection 订单 {get { return _wrappedOrders; } }
// 公共方法。

 public void AddOrder(Order order)
 {
    _orders.Add(order);
 }

// Private fields.
private ICollection<Order> _orders = new List<Order>();
private WrappedCollection<Order> _wrappedOrders = new WrappedCollection<Order>(_orders, this.AddOrder, null, null);
}

还有一些其他方法可以调用 WrappedCollection 构造函数
例如，要覆盖添加但保持删除和清除正常

private WrappedListCollection<Order> _orders = new WrappedListCollection(this.AddOrder,  (Order o) => _orders.RemoveFromInnerCollection(o), () => _orders.ClearInnerCollection());

，我同意如果 EF 不要求集合公开是最好的，但此解决方案允许我控制集合的修改。

对于阻止访问集合进行查询的问题，可以使用上面的方法 2) 并设置 WrappedCollection GetEnumerator 方法抛出 NotSupportedException。然后您的 GetOrder 方法可以保持原样。然而，更简洁的方法可能是公开包装的集合。例如：

 public class WrappedCollection<T> : WrappedCollectionBase<T>
 {
    public ICollection<T> InnerCollection { get; private set; }

    public WrappedCollection(ICollection<T> collectionToWrap, Action<T> addItemFunction, Func<T, bool> removeItemFunction, Action clearFunction)
        : base(addItemFunction, removeItemFunction, clearFunction)
    {
        this.InnerCollection = collectionToWrap;
    }


    protected  override ICollection<T> GetWrappedCollection()
    {
        return this.InnerCollection;
    }
}

那么 GetOrder 方法中的调用将变为

_orders.InnerCollection.Where(x => x.Id == id).Single();

Answer 2

实现此目的的另一种方法是为每个 POCO 创建一个关联的接口，以仅在持久性/域层之外公开您想要的内容。您还可以连接 DbContext 类来隐藏和控制对 DbSet 集合的访问。事实证明，DbSet 属性可以受到保护，模型构建器在创建表时会选取它们，但当您尝试访问集合时，它们将为空。可以使用工厂方法（在我的示例中为 CreateNewContext）代替构造函数来获取接口 DbContext 以隐藏 DbSet 集合。

编码方面需要付出相当多的额外努力，但如果在 POCO 中隐藏实现细节很重要，那么这会起作用。

更新：事实证明，如果 DBSet 受到保护，您可以填充它们，但不能直接在 DBContext 中填充它们。它们不能是聚合根（即实体的可访问性必须通过公共 DBSet 实体之一中的集合来实现）。如果隐藏 DBSet 的实现很重要，那么我描述的接口模式仍然相关。

public interface ICustomer
{
   void AddOrder(IOrder order);
   IOrder GetOrder(long id);
}

public Customer : ICustomer
{
   // Exposed methods:
   void ICustomer.AddOrder(IOrder order)
   {
      if (order is Order)
         orders.Add((Order)order);
      else
         throw new Exception("Hey! Not a mapped type!");
   }

   IOrder ICustomer.GetOrder(long id)
   {
      return orders.Where(x => x.Id).Single();
   }

   // public collection for EF
   // The Order class definition would follow the same interface pattern illustrated 
   // here for the Customer class.
   public ICollection<Order> orders = new List<Order>();
}

public interface IMyContext
{
   IEnumerable<ICustomer> GetCustomers();
   void AddCustomer(ICustomer customerObject);
   ICustomer CreateNewCustomer()
}


public class MyContext : DbContext, IMyContext
{
   public static IMyContext CreateNewContext() { return new MyContext(); }

   public DbSet<Customer> Customers {get;set;}
   public  DbSet<Order> Orders {get;set;}

   public IEnumerable<ICustomer> GetCustomers()
   {
      return Customers;
   }

   public void AddCustomer(ICustomer customerObject)
   {
      if (customerObject is Customer)
         Customers.Add((Customer)customerObject);
      else
         throw new Exception("Hey! Not a mapped type");
   }

   public ICustomer CreateNewCustomer()
   {
      return Customers.Create();
   }

   // wrap the Removes, Finds, etc as necessary. Remember to add these to the 
   // DbContext's interface

   // Follow this pattern also for Order/IOrder

}

Answer 3

如果您将 _orders 集合的名称更改为数据库中订单表的名称，这应该可以工作。 EF 按照约定将表/字段名称映射到集合/属性。如果您想使用不同的名称，您可以编辑 edmx 文件中的映射。

AFAIK 你可以保留 private 修饰符不变。集合不需要公开。