ASP.NET Core 3.1系列（25）——Autofac中的泛型注册和程序集注册

最新推荐文章于 2024-08-14 03:47:41 发布
最新推荐文章于 2024-08-14 03:47:41 发布
阅读量1.6k 收藏 9
点赞数 2
分类专栏： ASP.NET Core C# 文章标签： ASP.NET Core
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/herrydong/article/details/128662295
版权
C# 同时被 2 个专栏收录
72 篇文章 18 订阅
订阅专栏
ASP.NET Core
32 篇文章 43 订阅
订阅专栏

1、前言

在实际开发业务中，泛型的应用非常广泛，而这也就产生了一个问题：泛型类和泛型接口该怎么注册？难道要开发者一行一行去写泛型构造参数吗？同时，实际业务中往往也会对项目进行分层设计，例如接口层、实现层。对于这种处于不同程序集的接口和类，又有没有什么高效的方法对其进行处理呢？本文就来介绍一下如何利用Autofac来处理这两类问题。

2、Autofac中的泛型注册

新建泛型接口、泛型类、实体类，代码如下：

public interface IService<TEntity> where TEntity : class
{
    string Get();
}

public class Service<TEntity> : IService<TEntity> where TEntity : class
{
    public string Get()
    {
        return typeof(TEntity).FullName;
    }
}

public class Cat { }
public class Dog { }

如果使用Autofac中的基础注册方法，代码如下：

using Autofac;
using System;

namespace App
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // 注册接口和类
            ContainerBuilder builder = new ContainerBuilder();
            builder.RegisterType<Service<Cat>>().As<IService<Cat>>();
            builder.RegisterType<Service<Dog>>().As<IService<Dog>>();

            // 构建容器
            IContainer container = builder.Build();

            // Cat
            IService<Cat> cat = container.Resolve<IService<Cat>>();
            Console.WriteLine(cat.Get());

            // Dog
            IService<Dog> dog = container.Resolve<IService<Dog>>();
            Console.WriteLine(dog.Get());
        }
    }
}

运行结果如下所示：

App.Cat
App.Dog

上面的代码虽然实现了泛型注册，但问题也是显而易见的：一旦实体类数量较多，开发者需要手写大量注册代码。在Autofac中，我们可以使用RegisterGeneric方法来实现泛型注册，代码如下：

using Autofac;
using System;

namespace App
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // 注册接口和类
            ContainerBuilder builder = new ContainerBuilder();
            builder.RegisterGeneric(typeof(Service<>)).As(typeof(IService<>));

            // 构建容器
            IContainer container = builder.Build();

            // Cat
            IService<Cat> cat = container.Resolve<IService<Cat>>();
            Console.WriteLine(cat.Get());

            // Dog
            IService<Dog> dog = container.Resolve<IService<Dog>>();
            Console.WriteLine(dog.Get());
        }
    }
}

使用RegisterGeneric方法的好处就是无需写大量的带泛型构造参数的注册代码。运行结果如下所示：

App.Cat
App.Dog

3、Autofac中的程序集注册

在实际业务中，一般会对项目进行分层设计。下图显示了一个简易的分层项目：

在这里插入图片描述

Repository层代码如下所示：

namespace App.Repository.Contract
{
    public interface ICatRepository
    {
        string GetCatMsg();
    }
}

namespace App.Repository.Contract
{
    public interface IDogRepository
    {
        string GetDogMsg();
    }
}

using App.Repository.Contract;

namespace App.Repository
{
    public class CatRepository : ICatRepository
    {
        public string GetCatMsg()
        {
            return "This is cat";
        }
    }
}

using App.Repository.Contract;

namespace App.Repository
{
    public class DogRepository : IDogRepository
    {
        public string GetDogMsg()
        {
            return "This is dog";
        }
    }
}

Service层代码如下所示：

namespace App.Service.Contract
{
    public interface ICatService
    {
        string Get();
    }
}

namespace App.Service.Contract
{
    public interface IDogService
    {
        string Get();
    }
}

using App.Repository.Contract;
using App.Service.Contract;

namespace App.Service
{
    public class CatService : ICatService
    {
        protected readonly ICatRepository _repository;

        public CatService(ICatRepository repository)
        {
            _repository = repository;
        }

        public string Get()
        {
            return _repository.GetCatMsg();
        }
    }
}

using App.Repository.Contract;
using App.Service.Contract;

namespace App.Service
{
    public class DogService : IDogService
    {
        protected readonly IDogRepository _repository;

        public DogService(IDogRepository repository)
        {
            _repository = repository;
        }

        public string Get()
        {
            return _repository.GetDogMsg();
        }
    }
}

如果使用Autofac的基础注册方法，可以写成如下形式：

using App.Repository;
using App.Repository.Contract;
using App.Service;
using App.Service.Contract;
using Autofac;
using System;

namespace App
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // 注册接口和类
            ContainerBuilder builder = new ContainerBuilder();
            builder.RegisterType<CatRepository>().As<ICatRepository>();
            builder.RegisterType<DogRepository>().As<IDogRepository>();
            builder.RegisterType<CatService>().As<ICatService>();
            builder.RegisterType<DogService>().As<IDogService>();

            // 构建容器
            IContainer container = builder.Build();

            // ICatService
            ICatService cat = container.Resolve<ICatService>();
            Console.WriteLine(cat.Get());

            // IDogService
            IDogService dog = container.Resolve<IDogService>();
            Console.WriteLine(dog.Get());
        }
    }
}

运行结果如下所示：

This is cat
This is dog

上面的代码虽然能够实现注册，但其实问题跟泛型注册一样：如果有很多接口和类，那么就需要写大量重复代码。一般来说，分层项目会对各层中的文件命名做一定的限制。例如，仓储层中的文件必须以Repository结尾，服务层中的文件必须以Service结尾。这就给我们提供了一个思路：能否通过加载程序集批量获取文件名称，通过文件名称的匹配来实现接口和类的注册？其实，Autofac中的RegisterAssemblyTypes方法就支持这么做，代码如下：

using App.Service.Contract;
using Autofac;
using System;
using System.Reflection;

namespace App
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // 注册接口和类
            ContainerBuilder builder = new ContainerBuilder();

            // 注册Repository
            Assembly repository = Assembly.Load("App.Repository");
            Assembly repositoryContract = Assembly.Load("App.Repository.Contract");
            builder.RegisterAssemblyTypes(repository, repositoryContract)
                   .Where(p => p.Name.EndsWith("Repository"))
                   .AsImplementedInterfaces();

            // 注册Service
            Assembly service = Assembly.Load("App.Service");
            Assembly serviceContract = Assembly.Load("App.Service.Contract");
            builder.RegisterAssemblyTypes(service, serviceContract)
                   .Where(p => p.Name.EndsWith("Service"))
                   .AsImplementedInterfaces();

            // 构建容器
            IContainer container = builder.Build();

            // ICatService
            ICatService cat = container.Resolve<ICatService>();
            Console.WriteLine(cat.Get());

            // IDogService
            IDogService dog = container.Resolve<IDogService>();
            Console.WriteLine(dog.Get());
        }
    }
}

运行结果如下所示：

This is cat
This is dog

程序集注册的好处是显而易见的：如果后续需要添加新的接口和类，我们也不需要修改代码，因为Autofac会自动扫描类库中文件，然后通过名称匹配进行注册。

4、结语

本文主要介绍了Autofac中的泛型注册和程序集注册，这两种注册方法具有非常高的实用性。如果你对项目进行了分层设计，同时项目中也存在大量泛型接口和泛型类，那么使用泛型注册和程序集注册将会达到事半功倍的效果。

HerryDong
关注
专栏目录
.Net core 3.1 AutoFac配置及各种注册方式
千金少的博客
12-19 1701
首先新建一个项目 1.安装对应Nuget包 2.实例化AutoFac工厂实例，替换默认容器工厂 public class Program { public static void Main(string[] args) { CreateHostBuilder(args).Build().Run(); } public static IHostBuilder CreateHostBuild
Asp.Net Core 3.1 WebApi 实现前后端分离，实现文件上传下载【02源码】
09-24
架构设计：ASP.Net Core 3.1 WebApi+Swagger+Jwt+Autofac。 分享初衷：最近在做前后端分离项目，用到了文件上传下载功能，找了很多类似的案例，基本上都是相互转载，很少有原创的(总之找了很久没找到合适的)，最后...
.net core使用autofac示例代码
04-23
在.net core上使用autofac进行依赖注入的示例，通过类型注册和通过反射程序集注册，数据库是mysql
Autofac通过反射程序集方式 注册 接口 与 实现 之间的关系
最新发布
weixin_29147045的博客
08-14 48
????优点Autofac 通过反射程序集的方式来注册接口与实现之间的关系，带来的好处：使用反射自动扫描并注册程序集中的所有类型，可以极大地减少手动编写注册代码的需要。这意呀着对于每个新的接口实现，你不需要更新一个集中的注册点，从而减少了出错的机会。减少了样板代码，使得代码库更加干净和易于维护。当你的项目增长，接口和实现的数量...
使用Autofac进行服务注册，适用版本.Net6(程序集、泛型)
m0_57423952的博客
07-16 287
使用Autofac进行服务注册，适用版本.Net6(程序集、泛型)
.net 6 web api中使用Autofac依赖注入框架实现批量自动扫描程序集注册服务
weixin_44442366的博客
03-28 1986
Autofac新建两个文件夹IService用于存放接口，里面存放有IEnd和IOperation两个接口类，Service用于存放实现类，存放有End和Operation两个实现类，我们要做的是自动依赖注入服务，自动让IEnd和End对应在Program.cs文件写入以下代码。
autofac文档：泛型
weixin_34281477的博客
06-09 137
AutoFac文档 目录 开始 Registering components 控制范围和生命周期 用模块结构化Autofac xml配置 与.net集成 深入理解Autofac 指导 关于 词汇表 泛型 给定一个开放的泛型，Autofac会提供一个具体的实现。 开放的泛型类型使用泛型服务注册，给定一个服务类型和一个实现类型 public interface ...
autofac使用架构体现泛型注入
weixin_30546933的博客
06-29 656
/// <summary> /// 定义一个容器 /// </summary> public static IContainer container { get; set; } /// <summary> /// 获取dal实例化对象 /// ...
ORM框架 整合asp.net core mvc和Dapper、Autofac实现依赖注入和AOP，同时结合Redis实现 _缓
07-11
ASP.NET Core MVC是一个广泛使用的开源Web应用程序框架，它结合了MVC设计模式和ASP.NET Core的高性能特性。在本项目中，我们将探讨如何整合ORM框架，特别是Dapper，以及Autofac依赖注入容器，以实现高效的数据访问和...
【ASP.NET编程知识】.Net Core中使用Autofac替换自带的DI容器的示例.docx
05-15
ASP.NET编程知识，特别是关于.Net Core中的依赖注入（DI）容器的使用，是现代Web开发中的重要组成部分。本文将探讨如何使用Autofac这个流行的第三方DI框架替换.Net Core内置的DI容器。 首先，让我们理解.Net Core...
Asp.net Core 3.1基于AspectCore实现AOP实现事务、缓存拦截器功能
01-19
在net core2.2时，我当时就尝试过用autofac实现aop，但这次我不想用autofac，我用了一个更轻量级的框架，AspectCore。 用起来非常非常的简单，但一开始还是走了一点弯路，主要是网上都是net core3以下的教程，3以下...
Autofac4 官方文档
04-09
Autofac官方文档PDF版本，可以直接访问官网查看，pdf版本仅为个人学习而下载
autoFac 程序集注册 简单试验
xie__jin__cheng的博客
11-02 243
autoFac 程序集注册 简单试验
Autofac多种注册方式
wBreak的博客
06-13 297
【代码】Autofac多种注册方式。
Autofac的基本使用---3、泛型类型
weixin_30443731的博客
08-30 303
Autofac的基本使用---目录 Autofac使用---泛型类型 使用的表是Teacher，创建相关的IDAL、DAL、IBLL、BLL层。 使用EF，创建一个Model层，存放edmx文件。 创建一个Infrastructure层，基础设施项目，使用泛型类型。 　　　　 1、控制台程序的使用 using System; using System.Collection...
.Net core 泛型服务的注册
Ray
03-25 1231
在.Net core注册一个泛型的服务 public interface IService<T> { async Task DoAction(); } public class Service<T> : IService<T> { public async Task DoAction() { .... do action } } ServiceCollection.AddScoped<typeof(ISer
.Net Core3.1下Autofac的使用
飞翔的学习笔记
03-05 1567
安装Autofac.Extensions.DependencyInjection包 在programe.cs下 public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) //改用Autofac来实现依赖注入 .UseServiceProviderFactory(n
ASP.NET Core依赖注册自动化实现
weixin_43263355的博客
08-08 738
概要 在ASP.NET CORE开发项目过程中，我们在封装了用户的业务逻辑之后，要按照ASP.NET 自带的DI框架的要求，将我们封装好的业务逻辑类注册到ServiceCollection容器中，这样做避免了我们手工实例化对象，为开发带来了便利。 但是我们也应该看到，在带来便利的同时，我们也不得不手工维护注册的代码。对于大型项目，用户的业务逻辑可能非常复杂，需要封装大量的业务类。同样，在项目迭代周期内，也会产生大量新的业务需求，需要反复修改注册的代码。 解决方案 基于当前的问题，本文提出一种服务自动发现，自
.Net Core3.1下使用Autofac实现依赖注入
极客神殿
06-27 1634
前言 Autofac是.NET领域最为流行的IOC框架之一，传说是速度最快的一个。它和C#语言的结合非常紧密，在使用过程中对你的应用的侵入性几乎为零，更容易与第三方的组件集成。主要优点如下（此段描述为转载）： 它是C#语言联系很紧密，也就是说C#里的很多编程方式都可以为Autofac使用，例如可以用Lambda表达式注册组件 较低的学习曲线，学习它非常的简单，只要你理解了IoC和DI的概念以及在何时需要使用它们 XML配置支持 自动装配 微软的Orchad开源程序使用的就是Autofac，从该源码可以看出
.net core3.1 使用autofac 用来依赖注入
05-27
1. 在 .NET Core 3.1 的项目中，首先需要安装 Autofac 的 NuGet 包。可以使用 Visual Studio 的 NuGet 包管理器或者使用命令行工具来进行安装。 2. 在应用程序的启动类中，需要创建一个 Autofac 的容器。可以使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值