给微软的依赖注入框架写一些扩展方法

给微软的依赖注入框架写一些扩展方法

Intro

现在在项目里大多都是直接使用微软的依赖注入框架，而微软的注入方式比较简单，不如 AutoFac 使用起来灵活，于是想给微软的依赖注入增加一些扩展，使得可以像AutoFac 一样比较灵活的注册服务

Extensions

RegisterTypeAsImplementedInterface

将类型注册为其实现的接口，比如 pubic class UserService:IUserService,IUserRepository{}，

注册 UserService 为 IUserService 和 IUserRepository

等效于：

services.AddSingleton<IUserService, UserService>();
services.AddSingleton<IUserRepository, UserService>();

实现代码：

/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="type">type</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <returns>services</returns>
public static IServiceCollection RegisterTypeAsImplementedInterfaces(this IServiceCollection services, Type type, ServiceLifetime serviceLifetime = ServiceLifetime.Singleton)
{
    if (type != null)
    {
        foreach (var interfaceType in type.GetImplementedInterfaces())
        {
            services.Add(new ServiceDescriptor(interfaceType, type, serviceLifetime));
        }
    }
    return services;
}

RegisterAssemblyTypesAsImplementedInterface

在上面的基础上，加载指定程序集中的类型（不指定程序集则使用当前应用程序域中所有程序集），可以通过 typesFilter 来过滤要注册的类型

使用示例：

services.RegisterAssemblyTypesAsImplementedInterface(t => !t.IsAbstract && t.IsClass && t.IsAssignableTo<IEventHandler>(), typeof(NoticeViewEventHandler).Assembly);

实现源码：


/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypesAsImplementedInterfaces(this IServiceCollection services,
    params Assembly[] assemblies)
    => RegisterAssemblyTypesAsImplementedInterfaces(services, typesFilter: null, ServiceLifetime.Singleton, assemblies);

/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypesAsImplementedInterfaces(this IServiceCollection services,
    ServiceLifetime serviceLifetime, params Assembly[] assemblies)
    => RegisterAssemblyTypesAsImplementedInterfaces(services, typesFilter: null, serviceLifetime, assemblies);

/// <summary>
/// RegisterTypeAsImplementedInterfaces, singleton by default
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypesAsImplementedInterfaces(this IServiceCollection services, Func<Type, bool> typesFilter, params Assembly[] assemblies)
    => RegisterAssemblyTypesAsImplementedInterfaces(services, typesFilter: typesFilter, ServiceLifetime.Singleton, assemblies);

/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypesAsImplementedInterfaces(this IServiceCollection services, Func<Type, bool> typesFilter, ServiceLifetime serviceLifetime, params Assembly[] assemblies)
{
    if (assemblies == null || assemblies.Length == 0)
    {
        assemblies = ReflectHelper.GetAssemblies();
    }

    var types = assemblies
        .Select(assembly => assembly.GetExportedTypes())
        .SelectMany(t => t);
    if (typesFilter != null)
    {
        types = types.Where(typesFilter);
    }

    foreach (var type in types)
    {
        foreach (var implementedInterface in type.GetImplementedInterfaces())
        {
            services.Add(new ServiceDescriptor(implementedInterface, type, serviceLifetime));
        }
    }

    return services;
}

RegisterAssemblyTypes

注册类型，这相当于 AutoFac 中 RegisterAssemblyTypes().AsSelf()

services.RegisterAssemblyTypes(t => !t.IsAbstract && t.IsClass && t.IsAssignableTo<IEventHandler>(), typeof(NoticeViewEventHandler).Assembly);

实现源码：

/// <summary>
/// RegisterAssemblyTypes
/// </summary>
/// <param name="services">services</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypes(this IServiceCollection services, params Assembly[] assemblies)
    => RegisterAssemblyTypes(services, null, ServiceLifetime.Singleton, assemblies);

/// <summary>
/// RegisterAssemblyTypes
/// </summary>
/// <param name="services">services</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypes(this IServiceCollection services,
    ServiceLifetime serviceLifetime, params Assembly[] assemblies)
    => RegisterAssemblyTypes(services, null, serviceLifetime, assemblies);

/// <summary>
/// RegisterAssemblyTypes
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypes(this IServiceCollection services,
    Func<Type, bool> typesFilter, params Assembly[] assemblies)
    => RegisterAssemblyTypes(services, typesFilter, ServiceLifetime.Singleton, assemblies);

/// <summary>
/// RegisterAssemblyTypes
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyTypes(this IServiceCollection services, Func<Type, bool> typesFilter, ServiceLifetime serviceLifetime, params Assembly[] assemblies)
{
    if (assemblies == null || assemblies.Length == 0)
    {
        assemblies = ReflectHelper.GetAssemblies();
    }

    var types = assemblies
        .Select(assembly => assembly.GetExportedTypes())
        .SelectMany(t => t);
    if (typesFilter != null)
    {
        types = types.Where(typesFilter);
    }

    foreach (var type in types)
    {
        services.Add(new ServiceDescriptor(type, type, serviceLifetime));
    }

    return services;
}

ServiceModule

在 AutoFac 中有一个 Module 的概念可以让我们更方便的注册，一般可以在一个 Module 里注册需要服务注册的服务，这样注册的好处在于容易做插件化，新的插件需要注册什么样的服务，外界并不知道，如果用 Module 的注册方式，我只需要调用插件中的 Module 就可以注册所需要的服务了

IServiceModule

类似于 AutoFac 中的 Module，我们也可以定义一个 IServiceModule，定义一个 ConfigueServices(IServiceCollection services) 的方法用来注册服务

public interface IServiceModule
{
    void ConfigureServices(IServiceCollection services);
}

ServiceModule Demo

public class BusinessServiceModule : IServiceModule
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddEFRepository();
        services.AddBLL();
        services.TryAddScoped<ReservationHelper>();
        services.TryAddSingleton<CaptchaVerifyHelper>();
        services.TryAddSingleton<OperLogHelper>();
    }
}

RegisterAssemblyModules

上面我们定义了一个 Module，下面来定义一个扩展方法来注册 module 中的服务信息

使用示例：

// load service modules
services.RegisterAssemblyModules(pluginAssemblies);

实现源码：

/// <summary>
/// RegisterAssemblyModules
/// </summary>
/// <param name="services">services</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceCollection RegisterAssemblyModules(
    [NotNull] this IServiceCollection services, params Assembly[] assemblies)
{
    if (assemblies == null || assemblies.Length == 0)
    {
        assemblies = ReflectHelper.GetAssemblies();
    }
    foreach (var type in assemblies.SelectMany(ass => ass.GetTypes())
        .Where(t => t.IsClass && !t.IsAbstract && typeof(IServiceModule).IsAssignableFrom(t))
    )
    {
        try
        {
            if (Activator.CreateInstance(type) is IServiceModule module)
            {
                module.ConfigureServices(services);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }

    return services;
}

Reference

原文地址：https://www.cnblogs.com/weihanli/p/12362576.html

时间： 2024-10-11 13:12:49

给微软的依赖注入框架写一些扩展方法的相关文章

快如闪电、超轻量级的基于.Net平台的依赖注入框架Ninject

一.为什么要使用依赖注入框架 依赖注入框架也叫IoC容器.它的作用使类与类之间解耦 我们看看为什么要用依赖注入框架,举个几个梨子: 1,高度耦合的类 有一个Order类,Order类是用于订单操作的,DataAccess使用的sqlserver的方式查询订单.看看代码: public class Order { private DataAccess dataAccess = new DataAccess(); public string QueryOrder() { return dataAcc

Dagger——Android上的依赖注入框架

* 你也可以去Github查看这片文章 简介 在开发程序的时候,会用到各种对象,很多对象在使用之前都需要进行初始化.例如你要操作一个SharedPreference,你需要调用getSharedPreferences(String name,int mode)来获取一个对象,然后才能使用它.而如果这个对象会在多个Activity中被使用,你就需要在每个使用的场景中都写下同样的代码.这不仅麻烦,而且增加了出错的可能.dagger的用途就是:让你不需要初始化对象.换句话说,任何对象声明完了就能直接用

Android Dagger依赖注入框架浅析

今天接触了Dagger这套android的依赖注入框架(DI框架),感觉跟Spring 的IOC差不多吧.这个框架它的好处是它没有采用反射技术(Spring是用反射的),而是用预编译技术,因为基于反射的DI非常地耗用资源(空间,时间) 由于现在开发都是用Android Studio了,所以我这里大概讲下配置Dagger框架的开发环境,需要怎么做. (由于Android Studio中用Gradle,所以跟传统我们用Eclipse配置的话,直接导入jar包,有点不一样.) 在开始看我的博文前,希望

iOS依赖注入框架系列（二）：设置Typhoon

在循环的最后一部分,我们遇到了依赖注入框架为iOS - 台风,并审查其项目Rambler.Pochta使用的基本示例. 这一次,我们进入它的内部结构的研究. 周期"在iOS中右依赖驱动的应用程序" 熟悉台风 该器件台风 模块化台风 台风技巧与诀窍 台风替代品 (可选)Rambler.iOS#3. 依赖注入的iOS. 幻灯片 (可选)Rambler.iOS#3. 依赖注入的iOS. 视频 介绍 要开始分析一个小字典将被广泛使用在这篇文章中的术语: 大会(读作[essembli]). 最近

安卓开发 第一篇 关于依赖注入框架dagger2的使用和理解

(这篇博客真是磨难重重啊,写到一半电脑蓝屏了,还好markdown编辑器保持了部分类容) 最近开始重构项目,在重构项目中用到了依赖注入框架dagger2,发现它确实很方便,能大大加快我们编写代码的速度,同时也很方便我们对于功能模块的解耦.在这里就不过多介绍dagger2了,大家谷歌 百度一下就能得到很多关于dagger2的介绍.学习dagger2是需要一定的学习成本的,我自己开始学习的时候也差不多花了一周的时间才弄明白怎样使用dagger2,下面就说说自己对dagger2的理解和使用方法. da

Spring.NET依赖注入框架学习--入门

Spring.NET依赖注入框架学习--入门 在学些Spring.net框架之前,有必要先脑补一点知识,比如什么是依赖注入?IOC又是什么?控制反转又是什么意思?它们与Spring.net又有什么关系 带着问题,我们一起来看看下面内容(适合刚刚学习或者对依赖注入还太懂的小神看---大神直接飘过) 对以上几个问题都滚瓜烂熟的直接跳下一篇 这里我找到一篇我认为比较好的博文   原地址:http://www.cnblogs.com/jhli/p/6019895.html ---感谢博主分享 1. Io

Spring.NET依赖注入框架学习--概述

Spring.NET依赖注入框架学习--Spring.NET简介 概述 Spring.NET是一个应用程序框架,其目的是协助开发人员创建企业级的.NET应用程序.它提供了很多方面的功能,比如依赖注入.面向方面编程(AOP).数据访问抽象及ASP.NET扩展等等.Spring.NET以Java版的Spring框架为基础,将Spring.Java的核心概念与思想移植到了.NET平台上. 企业级应用一般由多个物理层组成,每个物理层也经常划分为若干功能层.不同层次之间需要相互协作,例如,业务服务层一般需

ASP.NET Core技术研究-探秘依赖注入框架

原文:ASP.NET Core技术研究-探秘依赖注入框架 ASP.NET Core在底层内置了一个依赖注入框架,通过依赖注入的方式注册服务.提供服务.依赖注入不仅服务于ASP.NET Core自身,同时也是应用程序的服务提供者. 毫不夸张的说,ASP.NET Core通过依赖注入实现了各种服务对象的注册和创建,同时也实现了面向抽象的编程模式和编程体验,提升了应用程序的扩展性. 今天,我们普及一下ASP.NET Core中依赖注入的一些基本知识. 一.服务的注册 我们通过创建一个ASP.NET C

浅析依赖注入框架Autofac的使用

Autofac是一款IOC框架,比起Spring.NET,Unity,Castle等等框架,它很轻量级且性能也很高,下面小编给大家介绍下依赖注入框架Autofac的使用. 下面通过代码给大家分享下依赖注入框架Autofac的使用,具体如下所示:  Autofac是一款IOC框架,比较于其他的IOC框架,如Spring.NET,Unity,Castle等等所包含的,它很轻量级性能上也是很高的. 1)解压它的压缩包,主要看到Autofac.dll,Autofac.Configuration.dll,