Question

我有一个类似下面的类（C＃）：

public class Product {

    public int ID {get;set;}
    public string Name {get;set;}
    public double Price {get;set;}

    public void Save() {
        string sql = "INSERT INTO Product.....";
        Database.Execute(sql);
    }

    public void Delete() {
        string sql = "DELETE Product WHERE.....";
        Database.Execute(sql);
    }
}

我主要关心的是上面的代码违反了SOLID原则，因为它负责创建和删除自己。

也许这些Save和Delete方法应该放在Product实体之外的某个地方（可能是Factory / Repository？）。

Answer 1

我相信Facade模式在你的情况下会做得很好。 Facade模式也称为服务层。

在你的情况下，你基本上会有一个服务（一个类），它将拥有你需要的所有方法。您的服务应该是这样的。

class ProductService 
{
    public void Save(Product product)
    {
       // SAVE THE PRODUCT
    }

    public void Delete(Product product)
    {
        // DELETE PRODUCT
    }
}

您希望将班级注入要保存或删除产品的位置。这样，您所要做的所有工作都将在一个单独的类中，您的代码将变得更加清晰。让所有这些在存储过程中插入和删除statemenet也是一个好主意。

Answer 2

我将介绍您的模型实体，命令和查询模式以及数据库层或存储库。

你的模型是你的Product，这个对象应该是一个普通的对象：

public class Product : IEntity {
    public int ID { get; set; }
    public string Name { get; set; }
    public double Price { get; set; }
}

接下来，我将创建一个命令和查询界面，以便使用此实体：

public interface ICommand {} // Marker interface

public interface IQuery<TResult> {} // Marker interface

接下来定义ICommand和IQuery的处理程序：

public interface IHandleQuery<TQuery, TResult> where TQuery : IQuery<TResult> 
{
    TResult Handle(TQuery query);
}

public interface IHandleCommand<TCommand> where TCommand : ICommand
{
    void Handle(TCommand command);
}

现在，您可以清楚地指出并分离您的写（命令）和读（查询）方。

这意味着我们可以创建一个命令及其处理程序来保存Product，如：

public class SaveProduct : ICommand 
{
    public string Name { get; private set; }
    public double Price { get; private set; }

    public SaveProduct(string name, double price) 
    {
        Name = name;
        Price = price;
    }
}

public class HandleSaveProduct : IHandleCommand<SaveProduct> 
{
    private readonly IRepository<Product> _productRepository;

    public HandleSaveProduct(IRepository<Product> productRepository) 
    {
        _productRepository = productRepository;
    }

    public void Handle(SaveProduct command) 
    {
        var product = new Product {
            Name = command.Name,
            Price = command.Price
        };

        _productRepository.Save(product);
    }
}

在上面我们已经定义了一个用于处理这个实体的存储库，但是，您可以直接依赖于您的数据库上下文对它的查询/命令，或者您可以实现存储库模式使用GenericRepository<TEntity> : IRepository<TEntity>或只是单独的产品库：

public interface IEntity { } // Marker interface

public interface IRepository<TEntity> where TEntity : IEntity 
{
    TEntity Get(object primaryKey);

    void Save(TEntity entity); // should handle both new and updating entities

    void Delete(TEntity entity);

}

public class ProductRepository : IRepository<Product> 
{
    public Product Get(object primaryKey) 
    {
        // Database method for getting Product
    }

    public void Save(Product entity) 
    {
        // Database method for saving Product
    }

    public void Delete(Product entity) 
    {
        // Database method for deleting Product
    }
}

您永远不应该将您的Product实体返回到您的UI，而是使用视图模型，例如：

public class ProductViewModel {
    public int ID { get; set; }
    public string Name { get; set; }
    public double Price { get; set; }
    public DateTime Whatever { get; set; }
}

public class GetProductById : IQuery<ProductViewModel>
{
    public int Id { get; private set; }

    public GetProductById(int id)
    {
        Id = id;
    }
}

public class HandleGetProductById : IHandleQuery<GetProductById, ProductViewModel>
{
    private readonly IRepository<Product> _productRepository;

    public HandleGetProductById(IRepository<Product> productRepository) 
    {
        _productRepository = productRepository;
    }

    public ProductViewModel Handle(GetProductById query)
    {
        var product = _productRepository.Get(query.Id);
        return product.Select(x => new ProductViewModel {
            Name = x.Name,
            Price = x.Price;
        });
    }
}

请注意这是用记事本写的，可能无法100％编译，但你应该知道如何分离各种组件以便遵循SOLID。： - ）

Answer 3

您似乎想要某种Repository合同。你已经在[问题]中提到了它。该链接仅供参考 - 我不建议您实施一个。为什么呢？

因为像@Igor所说，如果您使用ORM，那么您将免费获得此合同。例如，NHibernate有一个ISession Query<T>()，Save()，Delete()等方法。这就是你所需要的。

几乎所有我参与的项目都在这个基础设施上进行了一些抽象。使用ORM合约（服务/存储库/等），所述抽象很弱，只能创建更多代码来维护，并且更高的技术债务和错误风险。

采取务实的方法：

不要通过内部的ADO.NET调用创建自己的Repository / ORM抽象来重新发明轮子。使用像Fluent NHibernate这样的实体ORM，这使得映射变得简单并且易于与数据交互（其他完美的替代方案可能是实体框架等）。如果这对你来说太多了，试试一些非常简单的东西，比如Dapper - 它是一个非常轻量级的ORM，可以映射到你的模型，就像怪异的魔法一样，你仍然可以编写所有自己的SQL。您将获得使用的ORM合约界面，我相信这是您在此处所要求的，您可以继续构建您的应用程序，而不是考虑过度工程。
通过在控制器中使用ORM合同来保持简单（＆＃39;控制器＆＃39;不必是MVC控制器，它可以是您应用的UI入口点。记住：避免不必要的抽象）。 Here are some simple examples.
人们希望keep things DRY，但奇怪的成瘾开发人员必须#reusingallthethings意味着他们经常拥有存储库或服务，其中包含完美的ORM合同调用，并且通常只有一两次使用。忘了重用！使用Rule of Three并首先查询，保存和删除控制器中的逻辑，并在您知道需要时仅提取可重复使用的代码。
我知道these examples are trivial，但只是想象你需要返回一些数据和查询需要一些长linq表达式或带连接的复杂选择。现在假设你在一些地方需要同样的查询（它会发生。不经常，但你会有一些） - 复制并粘贴它！是的，这是正确的;你不能相信我说过，但我做到了。将相同的10行复制并粘贴到代码中的2,3或4个位置。它完全没问题。没有人会死。只要linq表达式本身（GetTop15TransactionsWithoutFeesExcludingCreditsGroupByDayRecentAtTop()任何人？），您不需要查询对象或Repository方法。

HTH。

将实体保存到数据库的设计模式

3 个答案: