Question

我有以下型号：

public class Customer
{
    public int Id {get; set;}
    public int GroupId {get; set;}
    public int Number {get; set;}
    public string Name {get; set;}
}

我的所有域模型都包含GroupId属性。为用户分配了GroupId，当他创建实体时，他的GroupId将与实体一起保存。用户只能对那些拥有GroupId。

的实体执行CRUD操作

目前，在我的服务层并基于PredicateBuilder扩展程序，我有一个方法可以在加载实体时添加GroupId：

public Customer Get(Expression<Func<Customer, bool>> where)
{
    var addGroup = groupRepository.Get(EntityType.Customer).AddGroup;
    if (addGroup)
        where = where.And(x => x.GroupId == user.GroupId);

    return customerRepository.Get(where);
}

每个Get方法执行上述操作。

有没有办法将上述代码集中在一个地方，而不必在我拥有的所有服务的每个Get方法中重复代码？

Answer 1

我的所有域模型都包含GroupId属性

然后，您的所有域模型都应该实现一个定义IHasGroup属性的接口（让我们称之为GroupId）。

然后，将代码分解出来应该很简单：

public Customer Get(Expression<Func<Customer, bool>> where)
{
    return GetHelper(EntityType.Customer, where, customerRepository.Get);
}

public static T GetHelper<T>(EntityType type, Expression<Func<T, bool>> where, 
                             Func<Expression<Func<T, bool>>, T> repositoryAccessor) 
    where T : IHasGroup
{
    var addGroup = groupRepository.Get(type).AddGroup;
    if (addGroup)
        where = where.And(x => x.GroupId == user.GroupId);

    return repositoryAccessor(where);
}

Answer 2

您可以提取界面。

public interface IGroup
{
 int GroupId {get; set;}
}

然后更新您的方法以使用界面：

public IGroup Get(Expression<Func<IGroup, bool>> where)
{
    var addGroup = groupRepository.Get(EntityType.Customer).AddGroup;
    if (addGroup)
        where = where.And(x => x.GroupId == user.GroupId);

    return customerRepository.Get(where);
}

将customerRepository和实体类型作为参数传递。您可能还需要为它们提取基本接口/类。

如果您无法更改返回类型，请使用其他方法提取此部分：

 var addGroup = groupRepository.Get(EntityType.Customer).AddGroup;
    if (addGroup)
        where = where.And(x => x.GroupId == user.GroupId);

Answer 3

将customerRepository封装在特定于用户的customerRepository中，例如

public class UserSpecificCustomerRepository : ICustomerRepository{
 private User _user;
 private ICustomerRepository _customerRepository;

 public UserSpecificCustomerRepository(User user, ICustomerRepository repo){
   _user = user;
   _customerRepository = repo;
 }

 public Customer Get(Expression<Func<Customer, bool>> where){
   where = where.And(x => x.GroupId == _user.GroupId);

  _customerRepository.Get(where);
 }
}

现在，您只有一个表达式扩展的位置。您的代码将更改为

public Customer Get(Expression<Func<Customer, bool>> where)
{
  var addGroup = groupRepository.Get(EntityType.Customer).AddGroup;
  if (addGroup) {
    return new UserSpecificCustomerRepository(user, customerRepository).Get(where);
  }

  return customerRepository.Get(where);
}

Answer 4

尝试使用baseEntity并在其基础上有一些常用方法然后在所有实体中继承baseEntity，以便为每个实体提供通用方法。

public class EntityBase<T>
{
    public virtual T Get(Expression<Func<T, bool>> where)
    {
        //your Logic here
    }

    public virtual IEnumerable<T> GetAll()
    {
      //Your Logic here
    }

    public virtual IEnumerable<T> GetMany(Expression<Func<T, bool>> where)
    {
        //Your Logic here
    }
}

希望这会对你有所帮助。

是否可以在一个地方概括这个代码？

4 个答案: