实体框架和领域驱动设计

Question

在花了几天时间尝试使用 EF 和 DDD 设置一个简单的应用程序后，我不得不说我感到非常沮丧，并认为我最好使用 Linq-to-SQL 而忘记了 DDD 和 EF。

与英孚

a) 你不能有合适的只读集合

b) 当您从一组子项中删除某些内容时，您经常会得到无法更改关系，因为一个或多个外键属性是不可为空的消息

c) 没有简单的方法可以删除父项的所有子项并重新插入它们

鉴于我发现的解决方法看起来很糟糕，所有这些对我来说都非常令人讨厌。 有人设法建立了一个简单的存储库来解决这些问题吗？

如果是的话，您是否愿意分享一些代码？！？

另外，我知道这是一个很大的话题，有没有人在大型 Web 应用程序中体验过任何真实世界的 DDD 好处？ 我们都知道这个理论，但是如果它真的值得麻烦的话，如果有一个想法会很好！

---

好的，到目前为止，我可以做的最好的事情是在查询某些内容时使用 AsNoTracking()。 这样我就可以得到我的信息，EF 不会在背后做任何他妈的事。 我现在可以从集合中删除，我也可以删除（谁会认为 id 必须为此返回 sql！）有谁知道使用 AsNoTracking 的任何陷阱？ 至于我可以根据我的对象生成 SQL 并填充它们或更新/删除它们，我很好。 无论如何，整个跟踪事情都走得太远了？

---

namespace EShop.Models.Repositories
{
public class CustomerRepository : BaseRepository, IRepository<Customer, Int32>
{
    public CustomerRepository() : base(new EShopData()) { }

    #region CoreMethods

    public void InsertOrUpdate(Customer customer)
    {
        if (customer.CustomerId > 0)
        {
            // you cannot use remove, if you do you ll attach and then you ll have issues with the address/cards below
            // dbContext.Entry<CustomerAddress>(address).State = EntityState.Added; will fail
            dbContext.Database.ExecuteSqlCommand("DELETE FROM CustomerAddress WHERE CustomerId = @CustomerId", new SqlParameter("CustomerId", customer.CustomerId));
            dbContext.Database.ExecuteSqlCommand("DELETE FROM CreditCard WHERE CustomerId = @CustomerId", new SqlParameter("CustomerId", customer.CustomerId));

            foreach (var address in customer.Addresses)
                dbContext.Entry<CustomerAddress>(address).State = EntityState.Added;
            foreach (var card in customer.CreditCards)
                dbContext.Entry<CreditCard>(card).State = EntityState.Added;

            dbContext.Entry<Customer>(customer).State = EntityState.Modified;
        }
        else
        {
            dbContext.Entry<Customer>(customer).State = EntityState.Added;
            foreach (var card in customer.CreditCards)
                dbContext.Entry<CreditCard>(card).State = EntityState.Added;
            foreach (var address in customer.Addresses)
                dbContext.Entry<CustomerAddress>(address).State = EntityState.Added;
        }
    }

    public void Delete(int customerId)
    {
        var existingCustomer = dbContext.Customers.Find(customerId);

        if (existingCustomer != null)
        {
            //delete cards
            var creditCards = dbContext.CreditCards.Where(c => c.CustomerId == customerId);
            foreach (var card in creditCards)
                dbContext.Entry<CreditCard>(card).State = EntityState.Deleted;

            //delete addresses
            var addresses = dbContext.CustomerAddresses.Where(c => c.CustomerId == customerId);
            foreach (var address in addresses)
                dbContext.Entry<CustomerAddress>(address).State = EntityState.Deleted;

            //delete basket
            dbContext.Entry<Customer>(existingCustomer).State = EntityState.Deleted;
        }
    }

    public Customer GetById(int customerId)
    {
        return dbContext.Customers.Include("Addresses").AsNoTracking().SingleOrDefault(c => c.CustomerId == customerId);
    }

    public IList<Customer> GetPagedAndSorted(int pageNumber, int pageSize, string sortBy, SortDirection sortDirection)
    {
        return null;
    }

    public void Save()
    {
        dbContext.SaveChanges();
    }

    #endregion CoreMethods


    #region AdditionalMethods

    #endregion AdditionalMethods

}

}

Answer 1

对 b 的响应：当您创建数据库时，您必须要么级联删除（即数据库也删除所有相关的子记录）或使外键可以为空。 那么你就不会得到那个错误。 这不应该归咎于 EF，而是关系数据库处理约束的方式。 你可以在你的 EDMX 中配置它，你的代码首先或者在数据库端使用 DDL。 取决于您如何设置项目的决定。

对 c 的回应：更一般的感觉，但删除所有子项并重新插入听起来很容易出错并且有“气味”。 至少只有在绝对需要时我才会这样做。 从性能的角度来看，更新可能更快。 也许您可以重新思考为什么选择删除和​​重新插入的问题？

Answer 2

好的，我想我现在已经受够了，所以我将总结我相当消极的经历

a）这是可能的，但由于这是第 5 版，我希望会有更好的结果。 可能最简单和更简单的解决方法可以在这里找到http://edo-van-asseldonk.blogspot.co.uk/2012/03/readonly-collections-with-entity.html或者我想你甚至可以想出你自己的readonly 特定于手头问题的集合，例如 BasketProductsReadOnlyCollection 如果您有一个篮子及其产品的集合。

b) 可能我们无论如何都不必担心 a。 鉴于这里的问题，微软在“天才之举”中几乎不可能编写正确的 DDD 代码。 如果您的 Products 表中有一个 Basket 和 Products 的 BasketId 不可为空，那么如果您执行 Basket.RemoveProduct(product)，就会遇到麻烦。 删除这样的内容意味着删除的是“关系”而不是记录。 所以 EF 会尝试将 BasketId 设置为 null，如果它不能，它会抛出一个异常（不，我不想让它可以为 null 只是为了适合 EF，即使我想要如果我和一个不这样做的 DBA 一起工作怎么办？）需要做的是调用 dbContext.Products.Remove(product) 以确保它被删除。 这基本上意味着您的业务逻辑代码需要了解 dbContext

c) 我不能再被打扰了！ 再次在 StackOverflow 上有关于此的回应，您可能会启动并运行一些东西，但它不应该那么困难和违反直觉。

至于更大的图景，我查看了适用于“分离”实体的 N 层建议。 我读了朱莉娅·勒曼 (Julia Lerman) 的一本书，她似乎是该主题的权威，但我没有留下深刻的印象。 整个附加对象图的工作方式以及推荐的处理方式再次非常反直觉。 她推荐的使事情变得“简单”的方法是让每个对象在您的业务代码中记录其状态！ 不适合我。

我不认为自己是建筑天才或其他什么东西，也许我错过了一些东西（或很多），但对我来说，EF 的努力似乎放错了地方。 他们花了很多时间和金钱来实施这个应该为你做所有事情的整个跟踪系统（典型的 MS，他们认为我们太愚蠢或无法照顾自己的东西），而不是专注于其他可以使这个产品成为产品的事情更容易使用。

我想从我的 ORM 中为我提供对象中的数据，然后让我一个人以我想要的任何方式处理它们，然后我想将我的对象或对象图传递回 ORM 并有自由告诉它是我想从对象图中添加/删除/更新的内容，以及如何在没有 EF 的当前恶作剧的情况下。

底线：我想我会再给 MS 几年时间，他们最终可能会做对，但这还不适合我。 MS 最终会在他们的网站上放一些适当的文档/教程吗？ 我记得几年前读过一篇关于 NHibernate 的 30000 页 PDF 教程。

Answer 3

a) 你一开始想做什么？ 您不能将集合设为私有并仅公开对其进行快照的公共属性吗？

b) 要从数据库中删除子实体，请使用dbcontext.ThatEntitySet.Remove(child) ，而不是parent.Children.Remove(child) 。

或者，您可以通过将子项中的外键作为主键的一部分来建立识别关系。 然后parent.Children.Remove(child)将从数据库中删除一行。

c) 看起来你在做一些愚蠢的事情。 如果您提供详细信息，我会提出不同的解决方案。

大话题：您的域是否足够复杂？ 或者您只是想应用……在简单的 CRUD 应用程序中强制使用 DDD 模式？ 你有什么业务规则？ 不变量？ 您的实体有哪些方法？ 有什么政策吗？

为什么需要 InsertOrUpdate 方法？ 我想您发明了它是因为您使用相同的表单来创建和更新实体。 这是一个强烈的信号，你只是在做一个 CRUD 应用程序。

Answer 4

万一其他人为此苦苦挣扎，这是我能想到的最佳实现，看看 RemoveFromBasket、AddToBasket 方法，虽然不理想，但至少你得到了一些东西并正在运行

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Web.Helpers;
 using EShop.Models.DomainModel;
 using System.Data;
 using EShop.Models.DataAccess;
 using System.Data.Objects;
 using System.Data.Entity.Infrastructure;

namespace EShop.Models.Repositories
{
public class BasketRepository : BaseRepository, IRepository<Basket, Int32>
{
    public BasketRepository() : base(new EShopData()) { }

    #region CoreMethods

    public void InsertOrUpdate(Basket basket)
    {
        var basketInDB = dbContext.Baskets.SingleOrDefault(b => b.BasketId == basket.BasketId);
        if (basketInDB == null)
            dbContext.Baskets.Add(basket);
    }

    public void Delete(int basketId)
    {
        var basket = this.GetById(basketId);
        if (basket != null)
        {
            foreach (var product in basket.BasketProducts.ToList())
            {
                basket.BasketProducts.Remove(product); //delete relationship
                dbContext.BasketProducts.Remove(product); //delete from DB
            }
            dbContext.Baskets.Remove(basket);
        }
    }

    public Basket GetById(int basketId)
    {
        // eager-load product info
        var basket = dbContext.Baskets.Include("BasketProducts")
                                      .Include("BasketProducts.Product.Brand").SingleOrDefault(b => b.BasketId == basketId);
        return basket;
    }

    public IList<Basket> GetPagedAndSorted(int pageNumber, int pageSize, string sortBy, SortDirection sortDirection)
    {
        throw new NotImplementedException();
    }

    public void Save()
    {
        dbContext.SaveChanges();
    }

    #endregion CoreMethods


    #region AdditionalMethods
    public void AddToBasket(Basket basket, Product product, int quantity)
    {
        var existingProductInBasket = dbContext.BasketProducts.Find(basket.BasketId, product.ProductId);
        if (existingProductInBasket == null)
        {
            var basketProduct = new BasketProduct()
            {
                BasketId = basket.BasketId,
                ProductId = product.ProductId,
                Quantity = quantity
            };
            basket.BasketProducts.Add(basketProduct);   
        }
        else
        {
            existingProductInBasket.Quantity = quantity;
        }
    }

    public void RemoveFromBasket(Basket basket, Product product)
    {
        var existingProductInBasket = dbContext.BasketProducts.Find(basket.BasketId, product.ProductId);
        if (existingProductInBasket != null)
        {
            basket.BasketProducts.Remove(existingProductInBasket); //delete relationship
            dbContext.BasketProducts.Remove(existingProductInBasket); //delete from DB
        }
    }

    public void RemoveFromBasket(BasketProduct basketProduct)
    {
        var basket = dbContext.Baskets.Find(basketProduct.BasketId);
        var existingProductInBasket = dbContext.BasketProducts.Find(basketProduct.BasketId, basketProduct.ProductId);
        if (basket != null && existingProductInBasket != null)
        {
            basket.BasketProducts.Remove(existingProductInBasket); //delete relationship
            dbContext.BasketProducts.Remove(existingProductInBasket); //delete from DB
        }
    }

    public void ClearBasket(Basket basket)
    {
        foreach (var product in basket.BasketProducts.ToList())
            basket.BasketProducts.Remove(product);
    }

    #endregion AdditionalMethods

}

}

Answer 5

好的，看起来我已经设法让 EF 5 或多或少按照我想要的方式工作。 问题 b 似乎对 EF5 没问题。 我认为我现在有一个合适的 DDD 篮子类和一个合适的存储库，对此非常满意，也许我毕竟对 EF 过于苛刻是不公平的！

public partial class Basket
{
    public Basket()
    {
        this.BasketProducts = new List<BasketProduct>();
    }

    public int BasketId { get; set; }
    public int? CustomerId { get; set; }
    public decimal TotalValue { get; set; }
    public DateTime Created { get; set; }
    public DateTime Modified { get; set; }

    public ICollection<BasketProduct> BasketProducts { get; private set; }

    public void AddToBasket(Product product, int quantity)
    {
        //BUSINESS LOGIC HERE
        var productInBasket = BasketProducts.SingleOrDefault(b => b.BasketId == this.BasketId &&  b.ProductId == product.ProductId);
        if (productInBasket == null)
        {
            BasketProducts.Add(new BasketProduct
            {
                BasketId = this.BasketId,
                ProductId = product.ProductId,
                Quantity = quantity
            });
        }
        else
        {
            productInBasket.Quantity = quantity;
        }
    }

    public void RemoveFromBasket(Product product)
    {
        //BUSINESS LOGIC HERE
        var prodToRemove = BasketProducts.SingleOrDefault(b => b.BasketId == this.BasketId && b.ProductId == product.ProductId);
        BasketProducts.Remove(prodToRemove);
    }
}

}

public class BasketRepository : BaseRepository, IRepository<Basket, Int32>
{
    public BasketRepository() : base(new EShopData()) { }

    #region CoreMethods
    //public void InsertOrUpdate(Basket basket, bool persistNow = true) { }

    public void Save(Basket basket, bool persistNow = true)
    {
        var basketInDB = dbContext.Baskets.SingleOrDefault(b => b.BasketId == basket.BasketId);
        if (basketInDB == null)
            dbContext.Baskets.Add(basket);

        if (persistNow)
            dbContext.SaveChanges();
    }

    public void Delete(int basketId, bool persistNow = true)
    {
        var basket = this.GetById(basketId);
        if (basket != null)
        {
            foreach (var product in basket.BasketProducts.ToList())
            {
                basket.BasketProducts.Remove(product); //delete relationship
                dbContext.BasketProducts.Remove(product); //delete from DB
            }
            dbContext.Baskets.Remove(basket);
        }
        if (persistNow)
            dbContext.SaveChanges();
    }

    public Basket GetById(int basketId)
    {
        // eager-load product info
        var basket = dbContext.Baskets.Include("BasketProducts")
                                      .Include("BasketProducts.Product.Brand").SingleOrDefault(b => b.BasketId == basketId);
        return basket;
    }

    public IList<Basket> GetPagedAndSorted(int pageNumber, int pageSize, string sortBy, SortDirection sortDirection)
    {
        throw new NotImplementedException();
    }

    public void SaveForUnitOfWork()
    {
        dbContext.SaveChanges();
    }

}