第二节 Autofac的注册

已于 2022-01-27 09:11:09 修改
阅读量1.6k 收藏
点赞数
分类专栏： autofac 文章标签： c# ioc
于 2022-01-26 15:27:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryancao530/article/details/122697910
版权

A) autofac的基本注册

您通过创建ContainerBuilder，通知构建器哪些组件，暴露哪些服务，来向Autofac注册组件。
注册的方式有三种：

  1. 通过反射创建（通过注册一个特定的.NET类型或开放的泛型）
  2. 通过提供现成的实例（您创建的对象的实例）
  3. 通过lambda表达式（执行实例化您的对象的匿名函数）

1.反射组件-按类型注册
当使用基于反射的组件时，Autofac会自动为您的类使用能够从容器获取的最多参数的构造函数。

using Autofac;
using Autofac.Core;
using System;

namespace ConsoleApp1
{
    public interface IOutput
    {
        void Show();
    } 
    public class ConsoleOutput : IOutput
    {
        public void Show()
        {
            Console.WriteLine("Show");
        }
    }         
    public interface IInput
    {
        void Get();
    }
    public class ConsoleInput : IInput
    {
        public void Get()
        {
            Console.WriteLine("Get");
        }
    }
    
    public class Component
    {
        private IOutput output;
        private IInput input;
        public Component(IOutput output)
        {
            this.output = output;
        }
        public Component(IOutput output,IInput input)
        {
            this.output = output;
            this.input = input;
        }
        public void Implement()
        {
            output?.Show();
            input?.Get();
        }
    }   
}

若IInput和IOutput服务都注册，则Component会自动选择两个参数的构造函数，反之选择一个参数的构造函数

namespace ConsoleApp1
{
	class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();
						
            containerBuilder.RegisterType<ConsoleInput>().As<IInput>();
            containerBuilder.RegisterType<ConsoleOutput>().As<IOutput>();
            containerBuilder.RegisterType<Component>();

            container = containerBuilder.Build();
            container.Resolve<Component>().Implement();          
            Console.ReadKey();
        }
    }
}

若想选择指定的构造函数可以用.UsingConstructor方法

namespace ConsoleApp1
{
	class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();

            containerBuilder.RegisterType<ConsoleInput>().As<IInput>();
            containerBuilder.RegisterType<ConsoleOutput>().As<IOutput>();
            containerBuilder.RegisterType<Component>().UsingConstructor(typeof(IOutput));

            container = containerBuilder.Build();
            container.Resolve<Component>().Implement();          
            Console.ReadKey();
        }
    }
}

注意：关于基于反射的组件的一个重要注意事项：通过RegisterType注册的任何组件类型必须是具体类型(比如接口就不行，因为接口不是具体类型)。 虽然组件可以将抽象类或接口公开为服务，但是您不能注册抽象类/接口组件。 如果你想到它是有道理的：在幕后，Autofac正在创建一个你注册的东西的实例。 你不能“新建”一个抽象类或一个接口。

2.实例组件
在某些情况下，您可能希望预先生成对象的实例，并将其添加到容器以供注册组件使用。您可以使用RegisterInstance方法执行此操作。
当你这样做时需要考虑的事情是Autofac自动处理注册组件的清理工作，你可能想要自己控制生命周期，而不是不是让Autofac来帮你调用Dispose 释放你的对象 。在这种情况下，您需要使用ExternallyOwned方法注册该实例。

namespace ConsoleApp1
{
	class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();

            ConsoleOutput output = new ConsoleOutput();
            containerBuilder.RegisterInstance<ConsoleOutput>(output).ExternallyOwned();

            container = containerBuilder.Build();
            using (var scope = container.BeginLifetimeScope())
            {
                scope.Resolve<ConsoleOutput>().Show();
            }

            Console.ReadKey();
        }
    }
}

3.Lambda表达式组件
反射是组件创建的一个相当不错的默认选择。但是，当组件创建逻辑不止是一个简单的构造函数调用时，事情就有些复杂了。Autofac可以接受用作组件创建者的委托或lambda表达式：
在这里插入图片描述
参数c是，组件上下文（一个IComponentContext对象）。您可以使用此来解析容器中的其他值，以帮助创建组件。使用这个参数而不是一个闭包来访问容器非常重要，这样可以保证可以正确地支持确定性清理和嵌套容器。可以使用此上下文参数来满足其他依赖关系 - 在示例中，A需要类型为B的构造函数参数，该参数可能具有其他依赖关系。

using Autofac;
using Autofac.Core;
using System;

namespace ConsoleApp1
{   
    public class Student
    {
        private string Name;
        private int Age;
        public Student(string name,int age)
        {
            Name = name;
            Age = age;
        }
        public void Show()
        {
            Console.Write(Name + ":" + Age.ToString());
        }
    }

    class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();

            containerBuilder.Register(o => new Student("Lily", 23));
            container = containerBuilder.Build();

            container.Resolve<Student>().Show();
            Console.ReadKey();
        }
    }
}

应用lambda表达式，通过参数值选择实现

using Autofac;
using Autofac.Core;
using System;

namespace ConsoleApp1
{           
    public interface Action
    {
        void Play(string name);
    }

    public class Action1 : Action
    {
        public void Play (string name)
        {
            Console.Write(name + " is listening to the music");
        }
    }

    public class Action2 : Action
    {
        public void Play(string name)
        {
            Console.Write(name + "is dancing");
        }
    }

    class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();
            containerBuilder.Register<Action>((c, o) =>
            {
                string type = o.Named<string>("name");
                if (type == "lily")
                {
                    return new Action1();
                }
                else if (type == "merry")
                {
                    return new Action2();
                }
                else
                {
                    return null;
                }
            });
            
            container = containerBuilder.Build();

            container.Resolve<Action>(new NamedParameter("name", "lily")).Play("lily");
            Console.ReadKey();
        }
    }
}

B) 服务与组件 – 特别留意AsSelf()方法

当您注册组件时，您必须告诉Autofac该组件公开的服务。
默认情况下，大多数注册只会将 自己 公开为已注册的类型，也就是说默认注册调用了AsSelf()方法，且组件只能由其公开的服务解析。
在这里插入图片描述
您可以使用任意数量的 服务 来显示组件，一旦公开服务，您可以基于该服务解析组件。
在这里插入图片描述
但请注意，一旦将组件公开为特定服务，将覆盖默认服务（组件类型）
在这里插入图片描述
如果要将组件公开为一组服务以及使用默认服务，请使用AsSelf方法
在这里插入图片描述
现在所有这些都将工作
在这里插入图片描述

C) 默认注册

如果多个组件公开相同的服务，Autofac将使用最后注册的组件作为该服务的默认提供商：
在这里插入图片描述
在这种情况下，FileLogger将是ILogger的默认值，因为它是最后一个注册的。
要覆盖此行为，请使用PreserveExistingDefaults（）修改器，在这种情况下，ConsoleLogger将是ILogger的默认值，因为FileLogger的后续注册使用了PreserveExistingDefaults（）。

D) 有条件注册D – OnlyIf(), IfNotRegistered()

OnlyIf() - 提供一个lambda，使用一个IComponentRegistry来确定是否应该发生注册。
IfNotRegistered() - 如果某些其他服务已注册，停止注册的快捷方式。

using Autofac;
using Autofac.Core;
using System;

namespace ConsoleApp1
{
    public interface IOutput
    {
        void Show();
    }              
    public interface IInput
    {
        void Get();
    }
    public class Test1 : IOutput
    {
        public void Show()
        {
            Console.Write("Show1");
        }
    }
    public class Test2 : IOutput
    {
        public void Show()
        {
            Console.Write("Show2");
        }
    }
    public class Test3 : IInput
    {
        public void Get()
        {
            Console.Write("GET1");
        }
    }
    class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();            
            containerBuilder.RegisterType<Test1>().As<IOutput>();
            containerBuilder.RegisterType<Test2>().As<IOutput>().IfNotRegistered(typeof(IOutput));
            containerBuilder.RegisterType<Test3>().As<IInput>().OnlyIf(o => o.IsRegistered(new TypedService(typeof(IOutput))));

            container = containerBuilder.Build();
            container.Resolve<IOutput>().Show();
            Console.ReadKey();
        }
    }
}

E) 注册组件带参数

Autofac提供了几种不同的参数匹配策略：

  1. NamedParameter - 按名称匹配目标参数
  2. TypedParameter - 按类型匹配目标参数（需要精确类型匹配）
  3. ResolvedParameter - 灵活的参数匹配
using Autofac;
using Autofac.Core;
using System;

namespace ConsoleApp1
{
    public interface IOutput
    {
        void Show();
    } 
    public class Test1 : IOutput
    {
        public string content;
        public Test1(string a)
        {
            content = a;
        }
        public void Show()
        {
            Console.Write(content);
        }
    }

    class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();
            containerBuilder.Register(o => new Test1("HAHA")).As<IOutput>().AsSelf();
            containerBuilder.RegisterType<Test1>().As<IOutput>().AsSelf().WithParameter("a", "yuyu");
            containerBuilder.RegisterType<Test1>().As<IOutput>().AsSelf().WithParameter(new NamedParameter("a", "Haha"));

            container = containerBuilder.Build();
            container.Resolve<IOutput>().Show();
            Console.ReadKey();
        }
    }
}

F) 属性自动关联 – PropertesAutowired()的使用

using Autofac;
using Autofac.Core;
using System;

namespace ConsoleApp1
{
    public interface IInput
    {
        void Get();
    }

    public class ConsoleInput : IInput
    {
        public void Get()
        {
            Console.Write("Input");
        }
    }
    public class Test1 
    {
        public IInput input { get; set; }
        public void Do()
        {
            input?.Get();
        }
    }

    class Program
    {
        private static IContainer container { get; set; }
        static void Main(string[] args)
        {
            var containerBuilder = new ContainerBuilder();
            containerBuilder.RegisterType<ConsoleInput>().As<IInput>();
            containerBuilder.RegisterType<Test1>().PropertiesAutowired();
            container = containerBuilder.Build();

            container.Resolve<Test1>().Do();
            Console.ReadKey();
        }

		//或
		//static void Main(string[] args)
       	// {
        //    var containerBuilder = new ContainerBuilder();       
        //    containerBuilder.RegisterType<Test1>().WithProperty("input", new ConsoleInput());
        //    container = containerBuilder.Build();

        //   container.Resolve<Test1>().Do();
        //    Console.ReadKey();
        //}	
    }
}
cccryan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Asp.Net Core]Autofac单抽象多实现构造函数注入
德仔
12-06 554
Autofac单抽象多实现构造函数注入1.注册的时候可以指定一个标识2.在控制器中获取的时候获取一个Autofac的上下文，通过上下文+标识，得到不同的实现的实例；3.预览 1.注册的时候可以指定一个标识 #region 一个接口多个实现 containerBuilder.RegisterType<TestServiceA>().Named<ITestServiceA>("TestServiceA"); cont
.netcore autofac scrutor 集成
11-20
标题中的".netcore autofac scrutor 集成"指的是在.NET Core项目中整合Autofac和Scrutor这两个库，以便更好地实现依赖注入和服务注册。 1. Autofac集成： Autofac 提供了对.NET Core 的全面支持，可以通过在...
谈一谈autofac组件的实例范围
12-26
实例范围决定如何在请求之间共享服务。 原文地址：http://docs.autofac.org/en/latest/lifetime/instance-scope.html 每个依赖一个实例 使用这个选项，每次请求服务都会返回一个新实例。使用 InstancePerDependency() 指定。这是默认选项。下面的代码，第2行和第3行是等价的。 var builder = new ContainerBuilder(); builder.RegisterType<Worker>(); builder.RegisterType<Worker>().InstancePerDependency()
.net中的依赖注入框架Autofac
weixin_48083386的博客
05-15 1107
Autofac 是一个功能丰富的 .NET 依赖注入容器，用于管理对象的生命周期、解决依赖关系以及进行属性注入。本文将详细讲解 Autofac 的使用方法，包括多种不同的注册方式，属性注入，以及如何使用多个 ContainerBuilder 来注册和合并组件。我们将提供详细的源代码示例来说明每个概念。Autofac 是一个强大的 .NET 依赖注入容器，它提供了多种注册方式、属性注入以及合并多个 ContainerBuilder 的功能，使你能够更灵活地管理对象的生命周期和解决依赖关系。
Autofac多种注册方式
最新发布
wBreak的博客
06-13 177
【代码】Autofac多种注册方式。
Autofac中文文档--一、注册组件--2传递注册参数
chiyueqi的专栏
09-06 2586
官方文档：http://docs.autofac.org/en/latest/register/parameters.html 二、传递注册参数 当你注册组件时能够提供一组参数,可以在解析基于组件的服务时使用。(如果你宁愿在解析时提供参数,你可以这样做)。 1、有效的参数类型（Available Parameter Types） Autofac提供数个不同的参数匹配策略： Nam
autofac 注册
weixin_34237596的博客
08-28 143
1 注册的概念和方式 使用autofac 的ContainerBuilder 来注册组件（components---通常指实现类），并把它的服务（service---通常指接口,抽象类,类实例）暴露给调用方。 autofac 通过相似的 Register() 方法来进行注册，通过As() 方法来公开服务 1) 创建一个ContainerBuilder 来注册组件和服务 ...
AutoFac使用方法总结一：注册
weixin_33851604的博客
02-20 363
AutoFac是.net平台下的IOC容器产品，它可以管理类之间的复杂的依赖关系。在使用方面主要是register和resolve两类操作。 这篇文章用单元测试的形式列举了AutoFac的常用使用方法： 注册部分 使用RegisterType进行注册 1 [Fact] 2 public void can_resolve_myclass() 3 { 4...
autofac.json生成工具
11-23
标题中的“autofac.json生成工具”指的是一个用于创建Autofac框架的JSON配置文件的软件工具。Autofac是一个流行的.NET依赖注入容器，它帮助开发者管理对象的生命周期和依赖关系。通过使用此工具，用户可以更方便地为...
Autofac Demo
11-17
例如，如果我们有一个 `IService` 接口和它的实现类 `Service`，我们可以在 Autofac 的配置中注册服务： ```csharp var builder = new ContainerBuilder(); builder.RegisterType().As(); var container = builder....
DotNetCore-Autofac
10-05
2. **Autofac 特性**： - **组件注册**：Autofac 允许你注册类型，定义它们的构造函数、属性和方法依赖。 - **生命周期管理**：Autofac 支持多种生命周期，如单例、实例化、请求生命周期等，可以控制对象的创建和...
Autofac的实例
weixin_33971130的博客
03-30 126
http://www.360doc.com/content/14/1103/17/1039473_422223837.shtml http://www.jb51.net/article/70378.htm 转载于:https://www.cnblogs.com/ChineseMoonGod/p/5337464.html
一文学会Autofac的基础操作：几种实现注册方式、3种注入方式、生命周期、AOP以及过滤器实现依赖注入...
dotNET跨平台
08-10 1829
前言：直接开干。使用Autofac进行服务注册实践：新建三个项目，分别是webapi项目Wesky.Core.Autofac以及两个类库项目Wesky.Core.Interface和Wesky.Core.Service。在Webapi项目下，引用Autofac的三个包：Autofac、Autofac.Configuration和Autofac.Extensions.D...
Ioc容器Autofac系列（3）-- 三种注册组件的方式
weixin_30542079的博客
12-12 76
简单来说，所谓注册组件，就是注册类并映射为接口，然后根据接口获取对应类，Autofac将被注册的类称为组件。 虽然可像上篇提到的一次性注册程序集中所有类，但AutoFac使用最多的还是单个注册。这种注册共有三种方式，其中最简单的就是用As方法，例如，ArrayList继承了IEnumerable接口，若将其注册到Autofac中，写法如下所示： ContainerBuilder b...
ASP.NET Core 3.1系列（25）——Autofac中的泛型注册和程序集注册
HerryDong的博客
01-13 1510
在实际开发业务中，泛型的应用非常广泛，而这也就产生了一个问题：泛型类和泛型接口该怎么注册？难道要开发者一行一行去写泛型构造参数吗？同时，实际业务中往往也会对项目进行分层设计，例如接口层、实现层。对于这种处于不同程序集的接口和类，又有没有什么高效的方法对其进行处理呢？本文就来介绍一下如何利用Autofac来处理这两类问题。本文主要介绍了Autofac中的泛型注册和程序集注册，这两种注册方法具有非常高的实用性。
Using AutoFac
weixin_30360497的博客
12-25 47
第一次整理了下关于autofac的一些具体的用法 1. 安装 Autofac:Install-Package Autofac -Version 4.8.1 2. 创建两个类库项目，IService (用于编写接口)，ServiceImpl（用于创建实现类） IService 下 public interface IAnimalBark { void Bark(...
(5) 引入Autofac并将接口注册实现类
ying1979的专栏
03-24 690
首先引入Autofac库， cmd下运行 dotnet add package Autofac 成功后，在项目文件 MyWebApp.csproj 中可以看到增加了 <PackageReference Include="Autofac" Version="6.3.0" /> 增加一个类： code\db\AutofacConfig.cs using Autofac; using System; using System.Collections.Generic; using S
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值