Question

像我正在做的那样动态地解决依赖关系是否合适。无处不在，建议使用Constructor注入。我真的不明白我这样做的方式的缺点。代码片段如下..

Employee.cs

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public Department Department { get; set; }
}

IRepository.cs

public interface IRepository<TModel> where TModel : class
    {
        void Add();
        IEnumerable<TModel> GetAll();
        IEnumerable<TModel> GetByID();
    }

Repository.cs

public class Repository<TModel> : IRepository<TModel> where TModel : class
{
    public void Add()
    {
        throw new NotImplementedException();
    }

    public IEnumerable<TModel> GetAll()
    {
        throw new NotImplementedException();
    }

    public IEnumerable<TModel> GetByID()
    {
        throw new NotImplementedException();
    }
}

EmployeeController.cs

public class HomeController : ApiController
{
    IComponentContext _container;

    public HomeController(IComponentContext container)
    {
        this._container = container;
    }

    public Repository<TModel> Using<TModel>() where TModel :class
    {
        var repository = _container.Resolve(typeof(IRepository<TModel>));
        return repository as Repository<TModel>;
    }

    [HttpGet]
    public IEnumerable<Employee> GetEmployees()
    {
        return Using<Employee>().GetAll();
    }
}

Global.asax中

protected void Application_Start()
{
    GlobalConfiguration.Configure(WebApiConfig.Register);

    var builder = new ContainerBuilder();
    builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

    builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));

    var container = builder.Build(Autofac.Builder.ContainerBuildOptions.None);
    var webApiResolver = new AutofacWebApiDependencyResolver(container);
    GlobalConfiguration.Configuration.DependencyResolver = webApiResolver;
}

说我有5个存储库，构造函数注入将解析我发出的请求的所有5个依赖项。我可能不会为每个请求使用5个存储库。所以我想通过传递类型来动态地解析依赖关系，就像我在 Using<TModel>() 中做的那样。任何建议，将不胜感激..！！谢谢...... !!

Answer 1

不要直接在应用程序组件中使用容器;这会导致各种麻烦，例如可维护性和可测试性问题。直接从应用程序代码中解析实例是well-known anti-pattern称为服务定位器。

作为第一次重构，您可以改为应用Unit of Work模式。工作单元允许访问底层存储库。例如：

public interface IUnitOfWork
{
    IRepository<TModel> Repository<TModel>();
}

public sealed class HomeController : ApiController
{
    private readonly IUnitOfWork _unitOfWork;

    public HomeController(IUnitOfWork unitOfWork)
    {
        this._unitOfWork = unitOfWork;
    }

    [HttpGet]
    public IEnumerable<Employee> GetEmployees()
    {
        return this._unitOfWork.Repository<Employee>().GetAll();
    }
}

在Composition Root（其中it is allowed访问容器）中，我们现在可以创建一个动态解析存储库的IUnitOfWork实现：

private sealed class AutofacUnitOfWork : IUnitOfWork
{
    private readonly IComponentContext _container;

    public AutofacUnitOfWork(IComponentContext container)
    {
        this._container = container;
    }

    public IRepository<TModel> Repository<TModel>()
    {
        return _container.Resolve<IRepository<TModel>>();
    }
}

此模式大大简化了您的应用程序组件，并防止了服务定位器反模式通常导致的缺点。

尽管应用工作单元模式可能是朝着正确方向迈出的有用步骤，但更好的方法是直接跳过工作单元，只需将所需的存储库直接注入应用程序组件：

public sealed class HomeController : ApiController
{
    private readonly IRepository<Employee> _employeeRepository;

    public HomeController(IRepository<Employee> employeeRepository)
    {
        this._employeeRepository = employeeRepository;
    }

    [HttpGet]
    public IEnumerable<Employee> GetEmployees()
    {
        return this._employeeRepository.GetAll();
    }
}

说我有5个存储库，构造函数注入将解析我发出的请求的所有5个依赖项。我可能不会为每个请求使用5个存储库。

请注意，从性能角度来看，您通常不应该关心是否使用了依赖项。在大多数情况下，Autofac足够快，而且这不太可能导致生产系统出现任何性能问题。

从设计角度来看，如果一个类有很多依赖项，你应该更加担心，而方法只使用其中一些。这意味着该类中的方法几乎没有凝聚力。这表明该类应该分成多个较小的类;它有multiple responsibilities。

使用Autofac动态解决依赖关系

1 个答案: