冠军

导航

统计

依赖注入在 dotnet core 中实现与使用:2 使用 Extensions DependencyInjection

既然是依赖注入容器,必然会涉及到服务的注册,获取服务实例,管理作用域,服务注入这四个方面。

  • 服务注册涉及如何将我们的定义的服务注册到容器中。这通常是实际开发中使用容器的第一步,而容器本身通常是由框架来实例化的,大多数时候,并不需要自己初始化容器。
  • 获取服务实例这一步,在实际开发中通常也不涉及,服务示例一般是通过注入来实现的。这里只是为了让我们对容器的使用了解的更全面一些。
  • 管理作用域一般在开发中也不涉及,框架,例如 .NET 的 MVC 框架已经帮我们把这个问题处理了。
  • 服务注入是我们需要关注的,不同的依赖注入容器支持不同的注入方式。在使用中,我们会通过注入来获取服务对象的实例。而不是自己 new 出来。

 看起来很复杂,使用的时候其实很简单。

1. 服务注册

1.1 支持不同的作用域 Scope

DependencyInjection 通过 Add 方法来进行服务注册,三种不同的作用域通过三种带有不同后缀的 Add 方法来支持。
 
services.AddSingleton<IUserService, UserService>();
services.AddScoped<IUserService, UserService>();
services.AddTransient<IUserService, UserService>();

Singleton 就是单例,以后通过该容器获取出来的,都是同一个服务对象实例。

Scoped 就是限定了作用域,在每个特定的作用域中,只会有一个服务对象实例。作用域需要你自己来创建,后面在使用服务的时候,我们再介绍。

而 Transient 则在每次从容器中获取的时候,都对创建新的服务对象实例。  

三种作用域简单明了,后面我们介绍服务注册的时候,就不再关注服务的作用域,都使用单例来介绍,其它两种方式是相同的。

1.2 基于接口注册

这是最为常见的注册方式,在实际开发中,服务一般都有对应的接口。为了方便注册,在 .NET Core 中一般使用泛型方式进行注册,这样比较简洁。是最推荐的方式。

services.AddSingleton<IUserService, UserService>();

当然,也可以使用基于类型的方式注册,不过代码没有使用泛型方式优雅。你需要先获取服务的类型,再通过类型进行注册。

services.AddSingleton(typeof(IUserService), typeof(UserService));

1.3 直接注册实例

如果服务并没有对应的接口,可以直接使用对象实例注册,ServiceCollection 会直接使用该实例类型作为服务接口类型来注册,这种方式比较简单粗暴。

services.AddSingleton(typeof(UserService));

 

1.4 注册泛型服务

泛型是很强大的特性,例如,泛型的仓储,我们只需要一个泛型仓储,就可以通过它访问针对不同类型的数据。

容器必须要支持泛型的服务,例如,针对下面的简化仓储示例,注意这里的 Get() 简化为只返回默认值。

public interface IRepository<T>
{
    T Get(int id);
}

public class Repository<T>: IRepository<T> {
    public Repository() {
        Console.WriteLine(typeof(T).Name);
    }

    public T Get(int id){
        return default(T); 
    }
}

只需要注册一次,就可以获得不同实现的支持。但是,泛型比较特殊,不能这样写:

 services.AddSingleton<IRepository<>, Repository<>>();

你需要通过类型的方式来进行服务注册。

services.AddSingleton(typeof(IRepository<>), typeof(Repository<>));  

如果没有这个仓储接口的话,就可以这样注册。

services.AddSingleton(typeof(Repository<>));

如果涉及到多个类型的泛型,例如仓储的定义变成下面这样,id 的类型使用 K 来指定。

public interface IRepository<T, K>
{
    T Get(K id);
}

而仓储的实现也变成下面这样:

public class Repository<T, K>: IRepository<T, K> {
    public Repository() {
        Console.WriteLine(typeof(T).Name);
    }

    public T Get(K id){
        return default(T); 
    }
}

注册的时候,就需要写成下面的样子:

services.AddSingleton (typeof (IRepository<,>), typeof (Repository<,>));
 

1.5 工厂模式注册

除了让容器帮助构造服务对象实例,我们也可以自己定义构建服务对象实例的工厂供容器使用。

如果服务实现没有参数,例如 UserRepository,可以这样写:

services.AddSingleton<IUserRepository>( (serviceProvider) => {
    return new UserReposotory();
    } );

如果构造函数是有参数的,比如:

public class UserReposotory: IUserRepository { 
    public UserReposotory(string name){
        Console.WriteLine( name);
    }
}  

注册就变成了下面的样子,需要注意的是,工厂会得到一个 ServiceProvider 的实例供你使用。

services.AddSingleton<IUserRepository> ((serviceProvider) => {
            Console.WriteLine ("construction IUserReposority");
            return new UserReposotory ("Tom");
        });

1.6 直接使用 ServiceDescriptor 注册

实际上,上面各种注册方式最终都会通过创建一个服务描述对象来完成注册,它的定义如下,你可以看到上面各种注册方式所涉及的痕迹。

public class ServiceDescriptor
{
    public ServiceLifetime Lifetime { get; }
    public Type ServiceType { get; }
    public Type ImplementationType { get; }
    public object ImplementationInstance { get; }
    public Func<IServiceProvider, object> ImplementationFactory { get; }
}

所以,实际上,你可以通过自己创建这个服务描述对象来进行注册。

services.Add(ServiceDescriptor.Singleton<IUserService, UserService>());

殊途同归,其实与使用上面的方式效果是一样的。

2 管理 Scope

如果注册服务的时候,指定了服务是单例的,无论从哪个 Scope 中获得的服务实例,都会是同一个。所以,单例的服务与 Scope 就没有什么关系了。

如果注册服务的时候,指定了服务是瞬态的,无论从哪个 Scope 中获取服务实例,都会是新创建的,每次获取就新创建一个。所以,瞬态的服务与 Scope 也没有什么关系了。

只有在注册时声明是 Scoped 的服务,才会涉及到 Scope。所以,只有 Scoped 的服务才会涉及到 Scope。

在容器初始化之后,会创建一个根的 Scope 作用域,它是默认的。 

IServiceProvider provider = services.BuildServiceProvider ();

在需要作用域的时候,可以通过已经创建的 provider 来创建作用域,然后从这个新创建的作用域再获取当前的服务提供器。

IServiceProvider provider = services.BuildServiceProvider ();
IServiceScope scope = provider.CreateScope();

IServiceProvider scopedServiceProvider = scope.ServiceProvider;  

通过作用域的服务提供器获取服务对象实例的时候,就会影响到通过 Scoped 注册的服务了。

这种类型的服务在每一个 Scope 中只会创建一个。

在微软的实现中,不支持嵌套的 Scope。

3 注入服务

 现在又回到了涉及编程中的使用,在需要服务对象实例的时候,我们只需要注入。

微软的实现实际上只支持了构造函数注入。例如:

public class HomeController : Controller
{
    private readonly IDateTime _dateTime;

    public HomeController(IDateTime dateTime)
    {
        _dateTime = dateTime;
    }

 

4 常见问题

 多次注册问题

你可以对同一个服务类型多次注册,这并不会遇到异常。在获取服务对象实例的时候,是通过最后一次注册来支持的。

需要的话,也可以获取到所有注册的服务对象实例。

var instances = provider.GetServices(typeof(IUserService));  

不是直接注入服务,而是注入容器

容器本身也可以注入,它的类型是 IServiceProvider,这样,你可以自己来通过容器完成特殊的处理。

var sp = provider.GetService<IServiceProvider> ();
var userService = sp.GetService<IUserService> ();
Console.WriteLine (userService);

  

5 简化注册过程

 https://www.cnblogs.com/catcher1994/p/handle-multi-implementations-with-same-interface-in-dotnet-core.html

 

参考资料:

posted on 2019-08-31 12:28 冠军 阅读(...) 评论(...) 编辑 收藏