0

目前，我正在使用 ASP.NET MVC 构建一个典型的 3 层 Web 应用程序。我已经使用依赖注入（Autofac）设置它，如下所示：

public class UserController : BaseController
{
    private readonly IUserService _userService;
    public UserController(IUserService userService)
    {
        this._userService = userService;
    }
}

public class IUserService
{
    void InsertUser(User user);
    void UpdateUser(User user);
    void DeleteUser(User user);
}
public class UserService : IUserService
{
    private readonly IRepository<User> _userRepository;
    public UserService(IRepository<User> userRepository)
    {
        this._userRepository = userRepository;
    }
    public void InsertUser(User user)
    {
        _userRepository.Insert(user);
    }
    public void UpdateUser(User user)
    {
        _userRepository.Update(user);
    }
    public void DeleteUser(User user)
    {
        _userRepository.Delete(user);
    }
}

存储库是使用 EF 的典型通用存储库。

public interface IRepository<T> where T : BaseEntity
{
    void Insert(T entity);
    void Update(T entity);
    void Delete(T entity);
}

问题是我的应用程序有很多实体，对于每个实体，我必须在服务层复制上述代码以进行 CRUD 操作。例如：对于实体“角色”，我有“InsertRole”、“UpdateRole”、“DeleteRole”……还有更多其他实体。因此，我尝试通过使用如下静态方法将 CRUD 操作提取到静态类“CommonService”来重构以删除重复代码：

public static class CommonService
{
    public static void Insert<T>(T entity) where T : BaseEntity
    {
        var repository = EngineContext.Current.Resolve<IRepository<T>>();
        repository.Insert(entity);
    }
    public static void Update<T>(T entity) where T : BaseEntity
    {
        var repository = EngineContext.Current.Resolve<IRepository<T>>();
        repository.Update(entity);
    }
    public static void Delete<T>(T entity) where T : BaseEntity
    {
        var repository = EngineContext.Current.Resolve<IRepository<T>>();
        repository.Delete(entity);
    }
}

通过这个类，我将删除服务中用于 CRUD 操作的重复代码。在 Controller 中，我只需调用 CommonService.Insert(user);... 现在对我来说真的很好。我仍然有其他正常的服务方法，并且没有重复 CRUD。但我想知道除了单元测试之外，这种方法是否有任何缺点（我不会对 CRUD 进行单元测试）。Web环境（ASP.NET MVC）中的内存管理和并发处理有什么问题吗？我还没有使用 EF 实现数据处理的并发机制（同时更新实体......）

提前致谢！米尔多尔。

4

2 回答 2

2

如果您决定保留该静态实现，请创建一个使用它的接口和代理类，您仍然可以对使用它的实现进行单元测试。你不想放弃单元测试。

public interface ICommonService<T>
{
    void Insert<T>(T entity);
    void Update<T>(T entity);
    void Delete<T>(T entity);
}

并实现一个简单的代理类型，该代理类型实现ICommonService<T>并转发对静态类的调用。然后，您可以像以前一样依赖ICommonService<T>并在以后模拟测试。

我不会有静态类。我不认识EngineContext.Current，但它看起来像服务定位器模式。通常不鼓励这样做，因为它隐藏了您所依赖的内容，无法进行明显的检查。

您仍然可以拥有一个通用接口，例如ICommonService<T>，然后实现代理以依赖于IRepository<T>，

public class CommonService<T> : ICommonService<T> where T : BaseEntity
{
    private readonly IRepository<T> repository;

    public CommonService(IRepository<T> repository)
    {  
        if (repository == null) throw new ArgumentNullException(nameof(repository)); 
        this.repository = repository;
    }

    // and other methods
}

那么你可以让你的控制器依赖于ICommonService，并且你不必在幕后进行静态方法调用。

于 2016-02-07T16:30:19.323 回答
0

我知道这已经很老了，但只是遇到了这个问题，我想知道为什么不直接采用该静态实现并将其设为抽象类 - 类似于 BaseService。这样，您可以对方法进行单一实现，以删除您提到的所有重复代码，但如果任何特定实体需要任何特殊处理，您仍可以在每个特定服务实现中处理它。

于 2020-12-28T17:14:38.527 回答