RegisterDelegate 方法

Registers a factory delegate for creating an instance of “TService”.ister

通过 RegisterDelegate 方法传入自定义的工厂方法

示例 ：使用 RegisterDelegate 方法和自定义委托实现类型注册

class Register_delegate
{
    [Test]
    public void Example()
    {
        var container = new Container();
        // 这里通过 RegisterDelegate 方法，传入一个匿名委托
        container.RegisterDelegate<IService>(resolverContext => new CheerfulService { Greetings = "Hey!" });
        var x = container.Resolve<IService>();
        Assert.AreEqual("Hey!", ((CheerfulService)x).Greetings);
    }
    internal class CheerfulService : IService
    {
        public string Greetings { get; set; }
    }
}

IResolverContext 接口

• 通过 RegisterDelegate 方法提供的 IResolverContext 参数，可以在解析对象的同时解析它所依赖的其他对象

  class Register_delegate_with_resolved_dependencies
  {
    [Test]
    public void Example()
    {
        var container = new Container();
        container.RegisterDelegate(_ => new GreetingsProvider { Greetings = "Mya" });
        // 在解析 CheerfulService 对象时，通过 resolverContext 参数解析它所依赖的 GreetingsProvider 对象
        container.RegisterDelegate<IService>(resolverContext => new CheerfulService(resolverContext.Resolve<GreetingsProvider>()));
        var x = container.Resolve<IService>();
        Assert.AreEqual("Mya", ((CheerfulService)x).Greetings);
    }
    class GreetingsProvider
    {
        public string Greetings { get; set; }
    }
    class CheerfulService : IService
    {
        public string Greetings => _greetingsProvider.Greetings;
        public CheerfulService(GreetingsProvider greetingsProvider)
        {
            _greetingsProvider = greetingsProvider;
        }
        private readonly GreetingsProvider _greetingsProvider;
    }
  }

虽然使用自定义委托注册类型的功能很强大，但并DryIoc官方并不推荐，理由如下：

1. Memory leaks by capturing variables into delegate closure and keeping them for a container lifetime.
2. Delegate is the black box for Container, mostly because it should use theResolvecall inside to resolve the dependency cutting of the object graph analysis, which makes it hard to find type mismatches or diagnose other potential problems. Among the un-catched problems are:
   • Recursive Dependency
   • Captive Dependency

**
因此，尽量将它作为最后的选择。DryIoc 拥有很多更加有效的方法来覆盖自定义委托方法的需求。其中之一的选择是 FactoryMethod。

RegisterDelegate 方法的使用建议

将依赖对象作为 RegisterDelegate 方法的参数，由 DryIoc 的容器自动解析对象，而不是在委托内部手动解析对象（resolverContext.Resolve）。

• 这些注入的依赖对象的生命周期由容器控制。

• 由于不存在“黑箱操作”，因此“递归依赖”和“俘虏依赖”问题都能被容器捕获。

  class Register_delegate_with_parameters
  {
    [Test] public void Example()
    {
        var container = new Container();
        container.Register<A>(Reuse.Singleton);
        container.Register<B>(Reuse.Singleton);
        // 通过 RegisterDelegate 方法，同时注册 A，B 和 X
        container.RegisterDelegate<A, B, X>((a, b) => new X(a, b));
        Assert.IsNotNull(container.Resolve<X>());
    }
    class A {}
    class B {}
    class X 
    {
        public X(A a, B b) {}
    }
  }

  当类型未知时，RegisterDelegate 会难以使用

  当编译时类型未知，委托将会变得很难用。因为一旦写成了 type = typeof(Foo 后将无法提供写入一个新的类型。为了处理这种情况，DryIoc 允许使用运行时类型：

  示例 ：使用 RegisterDelegate 方法和自定义委托实现类型注册

  class Register_delegate_returning_object
  {
    [Test]
    public void Example()
    {
        var container = new Container();
        container.RegisterDelegate(typeof(IService), r => Activator.CreateInstance(typeof(Foo)));
        var x = container.Resolve<IService>();
        Assert.IsInstanceOf<Foo>(x);
    }
    class Foo : IService { }
  }

RegisterInstance 方法

RegisterInstance 允许将一个存在的实例对象注入到容器当中， 随后用于依赖注入。

示例 ：使用 RegisterInstance 方法注册一个已存在的实例对象（Instance）

class Register_instance_example
{
    [Test]
    public void Example()
    {
        var container = new Container();
        var a = new A();
        // 使用 RegisterInstance 方法将 a 对象注册进容器当中
        container.RegisterInstance(a);
        container.Register<B>();
        var b = container.Resolve<B>();
        // 容器解析 B 类对象时，需要为其构造函数解析一个 A 类对象，此时解析出来的 a 就是之前注册时提供的 a。
        Assert.AreSame(a, b.A);
    }
    class A { }
    class B
    {
        public readonly A A;
        public B(A a) { A = a; }
    }
}

使用 Use 方法将实例注入作用域

使用 Use 方法可跳过注册要求直接将实例注入到作用域当中。

警告：通过 Use 方法注入实例不支持 serviceKey , Wrappers 和D ecorators，不过它能够更佳的性能和更少的内存损耗。

示例 ：使用 Use 方法将实例注入作用域

class Example_of_scoped_and_singleton_instance
{
    [Test]
    public void Example()
    {
        var container = new Container();
        container.Register<B>();
        // 这里通过 OpenScope 方法打开一个新的作用域
        using (var scope = container.OpenScope())
        {
            var a = new A();
            // 这里使用 Use 方法将 a 注入到容器当中（容器没有注册A类）
            scope.Use(a);
            // 解析 b 的时候将之前 Use 的 a 对象注入到 b 中
            var b = scope.Resolve<B>(); 
            Assert.AreSame(a, b.A);
        }
        var anotherA = new A();
        container.Use(anotherA); // injected into singleton scope
        var anotherB = container.Resolve<B>(); // will inject `anotherA`
        Assert.AreSame(anotherA, anotherB.A);
    }
    class A { }
    class B
    {
        public readonly A A;
        public B(A a) { A = a; }
    }
}

示例 ：使用 Use 方法将 object 实例注入作用域（指定运行时类型）

class Typed_instance
{
    public void Example()
    {
        var container = new Container();
        // compile-time known type
        var a = new A();
        container.Use<ISomeService>(a);
        // 运行时已知类型，例如，为 object类型的实例 提供一个 type 参数
        object aa = a;
        container.Use(typeof(ISomeService), aa);
    }
    interface ISomeService {}
    class A : ISomeService {}
}

RegisterInitializer 方法

RegisterInitializer allows to pass the action to be invoked on created a service before returning it from resolve method, or before injecting it as dependency.

用于再解析过程中——即创建对象后，返回对象前执行初始化操作

示例 ：使用 RegisterInitializer 方法为“特定类型”添加初始化操作

class Register_initializer
{
    [Test] public void Example()
    {
        var container = new Container();
        container.Register<Logger>(Reuse.Singleton);
        container.Register<IService, MyService>();
        // 注册时，使用 RegisterInitializer 方法为 Iservice 类型增加初始化操作（日志记录）
        container.RegisterInitializer<IService>(
            (service, resolver) => resolver.Resolve<Logger>().Log("created"));
        container.Resolve<IService>();
        Assert.AreEqual("created", container.Resolve<Logger>().LogData[0]);
    }
    class Logger
    {
        public readonly List<string> LogData = new List<string>();
        public void Log(string s) => LogData.Add(s);
    }
    interface IService {}
    class MyService: IService {}
}

示例 ：使用 RegisterInitializer 方法为“所有类型”添加初始化操作

• RegisterInitializer 方法可利用 condition 参数设置自定义过滤条件：排除 Logger 类，否则陷入 StackOverflowException

  class Register_initializer_for_any_object
  {
    [Test] public void Example()
    {
        var container = new Container();
        var loggerKey = "logger";
        // 为 Logger 类手动设置了 serviceKey  
        container.Register<Logger>(Reuse.Singleton, serviceKey: loggerKey);
        container.Register<IService, MyService>();
        // 使用 RegisterInitializer 方法，利用 condition 参数将 Logger 类型排除出去，即解析 Logger 类型不记录日志
        container.RegisterInitializer<object>(
            (anyObj, resolver) => resolver.Resolve<Logger>(loggerKey).Log("created object"),
            condition: request => !loggerKey.Equals(request.ServiceKey));
        container.Resolve<IService>();
        Assert.AreEqual("created object", container.Resolve<Logger>(loggerKey).LogData[0]);
    }
    class Logger
    {
        public readonly List<string> LogData = new List<string>();
        public void Log(string s) => LogData.Add(s);
    }
    interface IService { }
    class MyService : IService { }
  }

  RegisterInitializer() 方法不仅仅适用于服务类型，还能适用于接口：

  container.RegisterInitializer<IDisposable>(
    (disposable, resolver) => resolver.Resolve<Logger>().Log("resolved disposable " + disposable));

  使用 Reuse 参数控制不同的初始化行为

  RegisterInitializer （DryIoc v4.5.0）提供 reuse 参数，用于控制不同作用域之间的初始话执行次数。

  示例 ：使用 RegisterInitializer 方法配合 Reuse.Scoped

  class RegisterInitializer_with_reuse_different_from_initialized_object
  {
    [Test] public void Example()
    {
        var container = new Container();
        container.Register<IFoo, Boo>(Reuse.Singleton);
        var scopedUsages = 0;
        container.RegisterInitializer<IFoo>((x, r) => ++scopedUsages, Reuse.Scoped);
        using (var scope = container.OpenScope())
            scope.Resolve<IFoo>();
        using (var scope = container.OpenScope())
            scope.Resolve<IFoo>();
        using (var scope = container.OpenScope())
            scope.Resolve<IFoo>();
        Assert.AreEqual(3, scopedUsages);
    }
    interface IFoo { }
    class Boo : IFoo { }
  }

RegisterPlaceholder 方法

Register a service without implementation which can be provided later in terms of normal registration with IfAlreadyRegistered.Replace parameter. When the implementation is still not provided when the placeholder service is accessed,then the exception will be thrown. 可在无服务类的情况下实现注册，随后使用 IfAlreadyRegistered 参数替换成“常规”注册即可。在未替换成“常规”注册前解析服务对象，将会抛出异常。

This feature allows you to postpone decision on implementation until it is later known. 这特性能够推迟类型注册，直到你直到确切的实现类型。

示例 ：延迟注册

class Register_placeholder
{
    [Test]
    public void Example()
    {
        var container = new Container();
        container.RegisterPlaceholder<IService>();
        var getService = container.Resolve<Func<IService>>();
        IService service;
        // Assert通过，因为 IService 还未正在注册导致异常
        Assert.Throws<ContainerException>(() => service = getService());
        // 注册时使用 IfAlreadyRegistered.Replace，用于实现注册替换
        container.Register<IService, Foo>(ifAlreadyRegistered: IfAlreadyRegistered.Replace);
        service = getService();
        Assert.IsInstanceOf<Foo>(service);
    }
    interface IService { }
    class Foo : IService { }
}

RegisterDisposer 方法

关于对象的生命周期：

The normal way to cleanup things is to implement IDisposable interface. If disposable service was registered with Reuse, and reuse scope is disposed, then the service will be disposed as well. For instance, registered singleton will be disposed when container (and therefore singleton scope) is disposed. 通常情况下，继承自 IDisposable 接口的实例对象会随着 reuse scope 释放而释放，singleton 对象会随着 container 释放而释放。

RegisterDispose 方法适用性：

But what if service for some reason does not implement IDisposable but still wants to invoke “release logic” when goes out of the scope. RegisterDisposer addresses such a need. 针对无法继承自 IDisposable 接口的实例对象，可通过 RegisterDispose 方法实现（逻辑） “释放”。

示例 ：在 RegisterDisposer 方法中为“实现类”执行“逻辑”释放操作

class Register_disposer
{
    [Test]
    public void Example()
    {
        var container = new Container();
        container.Register<FileAbstraction>(Reuse.Singleton);
        // 这里通过 RegisterDisposer 方法为 FileAbstraction 类注册释放时操作 CloseFile
        container.RegisterDisposer<FileAbstraction>(f => f.CloseFile());
        var file = container.Resolve<FileAbstraction>();
        file.ReadWriteStuff();
        // 容器释放，调用 file 的 CloseFile 方法
        container.Dispose(); 
        Assert.IsTrue(file.IsClosed);
    }
    internal class FileAbstraction
    {
        public bool IsClosed { get; private set; }
        public void CloseFile() => IsClosed = true;
        public void ReadWriteStuff() { }
    }
}

示例 ：在 RegisterDisposer 方法中为“服务类（接口）”执行“逻辑”释放操作

class Register_disposer_for_many_services
{
    [Test]
    public void Example()
    {
        var container = new Container();
        container.Register<X>(Reuse.Singleton);
        container.Register<Y>(Reuse.Singleton);
        // 这里 RegisterDisposer 方法注册的时 IClosable 接口
        container.RegisterDisposer<IClosable>(closable => closable.Close());
        var x = container.Resolve<X>();
        var y = container.Resolve<Y>();
        container.Dispose();
        Assert.IsTrue(x.IsClosed);
        Assert.IsTrue(y.IsClosed);
    }
    interface IClosable
    {
        bool IsClosed { get; } 
        void Close();
    }
    class X : IClosable
    {
        public bool IsClosed { get; private set; }
        public void Close() => IsClosed = true;
    }
    class Y : IClosable
    {
        public bool IsClosed { get; private set; }
        public void Close() => IsClosed = true;
    }
}

RegisterDisposer 方法支持利用 condition 参数设置条件

示例 ：在 RegisterDisposer 方法中利用 condition 参数设置自定义过滤条件

container.RegisterDisposer<IClosable>(closable => closable.Close(),
    condition: request => !request.GetKnownImplementationOrServiceType().IsAssignableTo<IDisposable>());