12

我正在使用 autofac 作为 Ioc 容器。我有三个班级：

class Service
{
     public Service(Repository rep,UnitOfWork context){}

}

Class Repository
{
     public Repository(UnitOfWork context){}
}

class UnitOfWork{}

Service 和 Repository 需要相同的 UnitOfWork 实例

怎么做？以及如何在 XmlConfiguration 中编写它

4

1 回答 1

32

编辑：我误读了这个，并认为这是一个关于如何使用 autofac 注册依赖项的问题。如果您想保持相同的 UnitOfWork，您需要将实例的生命周期限定为某些内容。如果您在 ASP.NET 或 WCF 应用程序中使用它，您可以像这样注册您的依赖项：

typeBuilder.RegisterType<UnitOfWork>().InstancePerLifetimeScope();
typeBuilder.RegisterType<Repository>();
typeBuilder.RegisterType<Service>();

为了使用像 Autofac 这样的容器，您需要做的第一件事是注册所有依赖项。在 Autofac 中，您可以通过几种方式做到这一点，但它们都依赖于使用 a ContainerBuilder. 依赖于扩展方法，ContainerBuilder因此请确保您有usingAutofac 命名空间的声明。

您可以显式定义工厂方法：

// Explicitly 
var builder = new ContainerBuilder();
builder.Register<UnitOfWork>(b => new UnitOfWork());
builder.Register<Repository>(b => new Repository(b.Resolve<UnitOfWork>()));
builder.Register(b => new Service(b.Resolve<Repository>(), b.Resolve<UnitOfWork>()));

使用 ContainerBuilder 我们访问Register<>()提供服务接口的方法（这是我们向容器询问服务的方式），在这种情况下，我不使用接口，只是使用实际类型。任何时候你向容器请求一个UnitOfWork它都会使用工厂方法new UnitOfWork()来生成一个。在现实生活中，您可能会要求一个IUnitOfWork. 这可能有点冗长，但是当您需要自定义逻辑来创建依赖项时，它非常方便。

您可以像使用任何其他依赖项容器一样使用构建器，只需注册类型。 

// Implicitly
var typeBuilder = new ContainerBuilder();
typeBuilder.RegisterType<UnitOfWork>();
typeBuilder.RegisterType<Repository>();
typeBuilder.RegisterType<Service>();

这种方法依赖于注册构建类所需的所有依赖项。然后容器将使用反射来解析任何构造函数参数。如果未注册参数，容器将抛出其无法解析的类型的异常。在这种情况下，服务依赖于UnitOfWork和Repository。Repository还依赖于UnitOfWork. 这些依赖关系表示为构造函数参数。为了从容器中请求 aRepository或 a Service，必须注册所有依赖项

您可以使用配置方法。

如果你使用的是 app.config 文件，你可以像这样定义你的配置文件：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="autofac" type="Autofac.Configuration.SectionHandler, Autofac.Configuration"/>
  </configSections>

  <autofac defaultAssembly="AutoFacTest">
    <components>
      <component
              type="AutoFacTest.Repository, AutoFacTest"
              service="AutoFacTest.Repository" />

      <component
               type="AutoFacTest.UnitOfWork, AutoFacTest"
               service="AutoFacTest.UnitOfWork" />

      <component
              type="AutoFacTest.Service, AutoFacTest"
              service="AutoFacTest.Service" />
    </components>
  </autofac>
</configuration>

首先，请注意我们必须定义一个配置部分（注意<ConfigSections>）。然后，我们可以创建一个<autofac>定义所有依赖项的部分。表示法非常简单，您基本上<component>为每个依赖项创建一个。每个组件都有一个service属性，该属性定义将被请求的类型。还有一个type属性定义了在请求服务实例时要创建的对象。这类似于请求builder.Register<UnitOfWork>(b => new UnitOfWork())的UnitOfWork服务（在这种情况下）也是要创建的类型。

要使用配置创建构建器，请使用ConfigurationSettingsReader()

// Config
var configBuilder = new ContainerBuilder();
configBuilder.RegisterModule(new ConfigurationSettingsReader("autofac"));

您必须传入配置部分的名称（在本例中为autofac）。配置依赖项后，您必须构建一个容器。ContainerBuilder包含执行此操作的方法：

var container = builder.Build();
var typeContainer = typeBuilder.Build();
var configContainer = configBuilder.Build();

一旦你有了容器，你就可以请求你的服务实例：

container.Resolve<Service>().DoAwesomeness();
typeContainer.Resolve<Service>().DoAwesomeness();
configContainer.Resolve<Service>().DoAwesomeness();

完整程序：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autofac;
using Autofac.Configuration;

namespace AutoFacTest
{
    class Program
    {
        static void Main(string[] args)
        {
            // Explicitly 
            var builder = new ContainerBuilder();
            builder.Register<UnitOfWork>(b => new UnitOfWork());
            builder.Register<Repository>(b => new Repository(b.Resolve<UnitOfWork>()));

            builder.Register(b => new Service(b.Resolve<Repository>(), b.Resolve<UnitOfWork>()));

            // Implicitly
            var typeBuilder = new ContainerBuilder();
            typeBuilder.RegisterType<UnitOfWork>();
            typeBuilder.RegisterType<Repository>();
            typeBuilder.RegisterType<Service>();

            // Config
            var configBuilder = new ContainerBuilder();
            configBuilder.RegisterModule(new ConfigurationSettingsReader("autofac"));

            var container = builder.Build();
            var typeContainer = typeBuilder.Build();
            var configContainer = configBuilder.Build();


            container.Resolve<Service>().DoAwesomeness();
            typeContainer.Resolve<Service>().DoAwesomeness();
            configContainer.Resolve<Service>().DoAwesomeness();
            Console.Read();
        }
    }

    public class Repository
    {
        private readonly UnitOfWork _unitOfWork;
        public Repository(UnitOfWork uow)
        {
            _unitOfWork = uow;
        }

        public void PrintStuff(string text)
        {
            Console.WriteLine(text);
        }
    }

    public class Service
    {
        private readonly Repository _repository;
        private readonly UnitOfWork _unitOfWork;

        public Service(Repository repo, UnitOfWork uow)
        {
            _repository = repo;
            _unitOfWork = uow;
        }
        public void DoAwesomeness()
        {
            _repository.PrintStuff("Did awesome stuff!");
            _unitOfWork.Commit();
        }
    }

    public class UnitOfWork
    {
        public bool Commit()
        {
            return true;
        }
    }


}
于 2012-07-26T03:58:00.087 回答