为了确保在使用仓库模式时业务规则的正确执行，可以利用设计模式中的一些高级模式来增强系统的灵活性和可维护性。以下是结合策略模式和命令模式的实现思路，以保证业务规则的正确执行，并提高代码的可扩展性和可维护性。

策略模式

策略模式允许定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。这一模式使得算法的变化独立于使用算法的客户。在业务规则中，我们可以将不同的业务规则视为不同的策略。

实现步骤

1. 定义业务规则接口 首先，定义一个业务规则接口，该接口规范了所有业务规则类必须实现的方法。例如，可以定义一个 IBusinessRule 接口。

   public interface IBusinessRule
   {
       bool IsSatisfiedBy(object candidate);
       string Message { get; }
   }
   

2. 具体业务规则类 为每个具体的业务规则创建类，实现 IBusinessRule 接口。例如，AgeValidationRule 用于验证用户年龄是否合法。

   public class AgeValidationRule : IBusinessRule
   {
       public bool IsSatisfiedBy(object candidate)
       {
           var age = candidate as int?;
           return age.HasValue && age.Value >= 18;
       }
   
       public string Message => "年龄必须大于等于18岁";
   }
   

3. 策略选择 在服务层或领域层中，根据不同的业务场景选择适当的业务规则策略。可以使用工厂模式或依赖注入来管理这些策略的选择。

   public class ValidationService
   {
       private readonly List<IBusinessRule> _rules;
   
       public ValidationService(IEnumerable<IBusinessRule> rules)
       {
           _rules = rules.ToList();
       }
   
       public bool Validate(object candidate)
       {
           foreach (var rule in _rules)
           {
               if (!rule.IsSatisfiedBy(candidate))
               {
                   Console.WriteLine(rule.Message);
                   return false;
               }
           }
           return true;
       }
   }
   

命令模式

命令模式将请求封装成对象，从而使你可以使用不同的请求、队列或者请求日志来参数化其他对象。命令模式也支持可撤销的操作。在业务规则中，可以将每个业务操作封装成一个命令，并通过命令执行器来统一管理这些命令。

实现步骤

1. 定义命令接口 定义一个命令接口，规范了所有具体命令类必须实现的方法。例如，可以定义一个 ICommand 接口。

   public interface ICommand
   {
       void Execute();
       void Undo();
   }
   

2. 具体命令类 为每个具体的业务操作创建类，实现 ICommand 接口。例如，AddProductCommand 用于添加产品。

   public class AddProductCommand : ICommand
   {
       private readonly IProductRepository _repository;
       private readonly Product _product;
   
       public AddProductCommand(IProductRepository repository, Product product)
       {
           _repository = repository;
           _product = product;
       }
   
       public void Execute()
       {
           _repository.Add(_product);
       }
   
       public void Undo()
       {
           _repository.Remove(_product);
       }
   }
   

3. 命令执行器 创建一个命令执行器类，负责管理命令的执行和撤销。可以使用队列来存储命令，支持事务管理。

   public class CommandExecutor
   {
       private readonly List<ICommand> _commands = new List<ICommand>();
   
       public void Execute(ICommand command)
       {
           command.Execute();
           _commands.Add(command);
       }
   
       public void Undo()
       {
           foreach (var command in _commands)
           {
               command.Undo();
           }
           _commands.Clear();
       }
   }
   

结合仓库模式

在仓库模式中，仓库类负责数据的存取操作，而业务规则的执行则由领域层或服务层负责。通过上述策略模式和命令模式的结合，可以确保业务规则在数据存取时正确执行。

示例

假设我们有一个 ProductRepository 仓库类，用于管理产品数据。

public class ProductRepository : IProductRepository
{
    private readonly CommandExecutor _commandExecutor;

    public ProductRepository(CommandExecutor commandExecutor)
    {
        _commandExecutor = commandExecutor;
    }

    public void Add(Product product)
    {
        var validationService = new ValidationService(new[] { new AgeValidationRule() });
        if (validationService.Validate(product))
        {
            var command = new AddProductCommand(this, product);
            _commandExecutor.Execute(command);
        }
        else
        {
            Console.WriteLine("业务规则验证失败，无法添加产品");
        }
    }

    public void Remove(Product product)
    {
        // 实现删除逻辑
    }
}

通过这种方式，我们不仅确保了业务规则的正确执行，还提高了代码的可扩展性和可维护性。