ASP.NET Core 3.1系列（26）——Autofac中的实例生命周期

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

1、前言

前面的博客主要介绍了Autofac中的一些注册方法，下面就来介绍一下Autofac中实例的生命周期。之前在介绍ASP.NET Core内置IoC容器的时候说过，实例的生命周期有：瞬时生命周期、域生命周期、全局单例生命周期，而Autofac在这三种周期之上又新增了若干周期模式，下面开始介绍。

2、Autofac中的生命周期

2.1、InstancePerDependency

InstancePerDependency表示瞬时生命周期，它是Autofac中默认的周期模式，在瞬时生命周期中，容器每次都会创建新的实例，代码如下：

using Autofac;
using System;

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

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

            // scope1
            using (var scope = container.BeginLifetimeScope())
            {
                IAnimal obj1 = scope.Resolve<IAnimal>();
                IAnimal obj2 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj1.GetHashCode());
                Console.WriteLine(obj2.GetHashCode());
            }

            Console.WriteLine("---------");

            // scope2
            using (var scope = container.BeginLifetimeScope())
            {
                IAnimal obj3 = scope.Resolve<IAnimal>();
                IAnimal obj4 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj3.GetHashCode());
                Console.WriteLine(obj4.GetHashCode());
            }
        }
    }
}

运行结果如下所示：

43527150
56200037
---------
36038289
55909147

可以发现：obj1、obj2、obj3、obj4的哈希值均不相同，因此它们是不同的实例。

2.2、InstancePerLifetimeScope

InstancePerLifetimeScope表示域生命周期。域周期表示在同一个域中，每个实例都是相同的，而不同域中的实例又是不同的，因此可以理解为在域中实现了单例模式，代码如下：

using Autofac;
using System;

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

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

            // scope1
            using (var scope = container.BeginLifetimeScope())
            {
                IAnimal obj1 = scope.Resolve<IAnimal>();
                IAnimal obj2 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj1.GetHashCode());
                Console.WriteLine(obj2.GetHashCode());
            }

            Console.WriteLine("---------");

            // scope2
            using (var scope = container.BeginLifetimeScope())
            {
                IAnimal obj3 = scope.Resolve<IAnimal>();
                IAnimal obj4 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj3.GetHashCode());
                Console.WriteLine(obj4.GetHashCode());
            }
        }
    }
}

运行结果如下所示：

43527150
43527150
---------
56200037
56200037

可以发现：obj1与obj2的哈希值相同，obj3与obj4的哈希值相同，因此obj1与obj2为同一实例，obj3与obj4为同一实例。

2.3、InstancePerMatchingLifetimeScope

InstancePerMatchingLifetimeScope也表示域生命周期，它允许开发者做更精细的控制，那么它与InstancePerLifetimeScope的区别在哪里？来看下面一段代码：

using Autofac;
using System;

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

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

            // scope1
            using (var scope = container.BeginLifetimeScope())
            {
                IAnimal obj1 = scope.Resolve<IAnimal>();
                IAnimal obj2 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj1.GetHashCode());
                Console.WriteLine(obj2.GetHashCode());

                Console.WriteLine("---------");

                // 子域
                using (var scope1 = scope.BeginLifetimeScope())
                {
                    IAnimal obj3 = scope1.Resolve<IAnimal>();
                    IAnimal obj4 = scope1.Resolve<IAnimal>();
                    Console.WriteLine(obj3.GetHashCode());
                    Console.WriteLine(obj4.GetHashCode());
                }
            }
        }
    }
}

上面的代码设置为InstancePerLifetimeScope模式，在域scope中又创建了一个子域scope1，运行结果如下：

43527150
43527150
---------
56200037
56200037

可以发现：子域中的obj3和obj4的哈希值相同，但它们与obj1和obj2的哈希值却不相同。因此obj1与obj2为同一实例，obj3与obj4为同一实例。现在切换为InstancePerMatchingLifetimeScope模式，代码如下：

using Autofac;
using System;

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

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

            // scope1
            using (var scope = container.BeginLifetimeScope("abc"))
            {
                IAnimal obj1 = scope.Resolve<IAnimal>();
                IAnimal obj2 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj1.GetHashCode());
                Console.WriteLine(obj2.GetHashCode());

                Console.WriteLine("---------");

                // 子域
                using (var scope1 = scope.BeginLifetimeScope())
                {
                    IAnimal obj3 = scope1.Resolve<IAnimal>();
                    IAnimal obj4 = scope1.Resolve<IAnimal>();
                    Console.WriteLine(obj3.GetHashCode());
                    Console.WriteLine(obj4.GetHashCode());
                }
            }
        }
    }
}

上面的代码在注册时打了一个标签，名称为abc，然后通过该标签名称创建域scope，运行结果如下所示：

43527150
43527150
---------
43527150
43527150

可以发现：obj1、obj2、obj3、obj4的哈希值均相同，它们为同一实例。因此可以这样理解：如果将生命周期设置为InstancePerMatchingLifetimeScope模式，那么在该域中，不管创建了多少子域，它们都会调用同一实例。

2.4、InstancePerRequest

InstancePerRequest表示在每次HTTP请求内实现单例。该周期模式只适用于Web项目，由于本文的例子基于控制台程序，因此不太方便举例说明。本质上这也是一种域内单例的周期模式，但并不经常使用。

2.5、InstancePerOwned

关于InstancePerOwned周期，相关的介绍不多，我在这里就凭借自己的一点理解来进行说明，如果有不对的地方还请大家指出来。首先新增一个类Zoo，代码如下：

namespace App
{
    public class Zoo
    {
        protected readonly IAnimal _animal;

        public Zoo(IAnimal animal)
        {
            _animal = animal;
        }

        public string Get()
        {
            return _animal.GetMsg();
        }
    }
}

然后在Autofac中注册该类，代码如下：

using Autofac;
using System;

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

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

            // scope1
            using (var scope = container.BeginLifetimeScope())
            {
                var cat = scope.Resolve<IAnimal>();
                Console.WriteLine(cat.GetMsg());

                var zoo = scope.Resolve<Zoo>();
                Console.WriteLine(zoo.Get());
            }
        }
    }
}

运行结果如下所示：

This is cat
This is cat

上面这段代码很简单，现在把代码改一下，把InstancePerOwned周期加进来：

using Autofac;
using System;

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

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

            // scope
            using (var scope = container.BeginLifetimeScope())
            {
                var cat = scope.Resolve<IAnimal>();
                Console.WriteLine(cat.GetMsg());

                var zoo = scope.Resolve<Zoo>();
                Console.WriteLine(zoo.Get());
            }
        }
    }
}

运行代码，程序报错，发现在创建Cat实例的时候发生异常，如下图所示：

在这里插入图片描述
这是因为InstancePerOwned模式会对Cat实例的创建做出限制：

builder.RegisterType<Cat>().As<IAnimal>().InstancePerOwned<Zoo>();

根据我对官方文档的理解，上面这行代码可以理解为：Cat实例的创建依赖于Zoo实例的创建。当Zoo实例被创建后，容器会自动创建Cat实例，同时在域scope内无法单独使用Cat实例，它只能在Zoo实例的内部进行调用。因此开发者无法在域scope内手动调用Resolve方法生成Cat实例。下面修改一下代码：

using Autofac;
using Autofac.Features.OwnedInstances;
using System;

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

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

            // scope
            using (var scope = container.BeginLifetimeScope())
            {
                var zoo = scope.Resolve<Owned<Zoo>>();
                Console.WriteLine(zoo.Value.Get());
                zoo.Dispose();
            }
        }
    }
}

运行结果如下所示：

This is cat

在使用InstancePerOwned周期时，我们需要使用Owned<>来接收容器创建的实例，然后对Value属性进行操作。在上面的代码中，当调用Resolve<Owned<Zoo>>时，Cat实例就会被自动创建。但无法直接调用。对象使用完后需要手动调用Dispose方法对其进行销毁。

2.6、SingleInstance

SingleInstance表示全局单例生命周期，这个比较好理解，即：所有创建的实例均为同一实例，代码如下：

using Autofac;
using System;

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

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

            // scope1
            using (var scope = container.BeginLifetimeScope())
            {
                IAnimal obj1 = scope.Resolve<IAnimal>();
                IAnimal obj2 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj1.GetHashCode());
                Console.WriteLine(obj2.GetHashCode());
            }

            Console.WriteLine("---------");

            // scope2
            using (var scope = container.BeginLifetimeScope())
            {
                IAnimal obj3 = scope.Resolve<IAnimal>();
                IAnimal obj4 = scope.Resolve<IAnimal>();
                Console.WriteLine(obj3.GetHashCode());
                Console.WriteLine(obj4.GetHashCode());
            }
        }
    }
}

运行结果如下所示：

43527150
43527150
---------
43527150
43527150

3、结语

本文主要介绍了Autofac中实例的生命周期。一般情况下，瞬时、域、单例三种周期模式应用较多，而其他的周期模式则相对较少，有兴趣的同志可以查看Autofac官方文档进行深入了解。

.NET/C# ⾯试题汇总系列：ASP.NET Core 004
Code365
07-07 468
（这里指的是4.x以下版本）是由 Microsoft 创建的开放源代码 Web 框架，助你使用 .NET 生成现代 Web 应用和服务。是一个成熟的框架，提供在 Windows 上生成基于服务器的企业级 Web 应用所需的服务。数百万开发人员在使用或使用过创建 Web 应用（使用人群多，代码完全开源）。ASP.NET Core 是对 ASP.NET 4.x 的重新设计，其中包括体系结构上的更改，产生了更精简、更模块化的框架。由CLR管理分配和释放的资源，也就是我们直接new出来的对象；
AutoFac 生命周期管理
千金少的博客
12-24 1002
public void ConfigureContainer(ContainerBuilder containerBuilder) { #region 指定控制器由AutoFac 进行实例获取 var assembly = this.GetType().GetTypeInfo().Assembly; var builder = new ContainerBuilder(); //新建Mvc管..
autofac的生命周期
浩瀚与渺小
10-17 960
autofac生命周期，寿命范围是一次性的,它们跟踪组件处理，完成后可以由GC回收 Instance Per Dependency每次都会返回一个新的实例，并且这是默认的生命周期。 { //瞬时生命周期-每一期获取对象都是一个全新的实例 ContainerBuilder builder = new ContainerBuilder(); builder.RegisterType<TestServiceA>().As<ITestServiceA>().InstancePerD.
Autofac 安装与使用教程
最新发布
gitblog_00520的博客
08-13 360
Autofac 安装与使用教程 AutofacAn addictive .NET IoC container项目地址:https://gitcode.com/gh_mirrors/au/Autofac 1. 项目目录结构及介绍 Autofac 的源码目录结构如下： src/Autofac: 主要的源代码库，包含了核心功能和容器实现。 test: 测试目录，包括单元测试和集成测试用例。 code...
AutoFac生命周期
ftfmatlab的博客
04-13 463
1.建立一个新的生命周期范围 您能够经过在任何现有生命周期做用域上从根容器开始调用BeginLifetimeScope()方法来建立生命周期做用域。生命周期做用域是可销毁的，他们跟踪组件的处置，因此确保你老是调用“Dispose()”或者把它们包装在“using”语句中。 　using(var scope = container.BeginLifetimeScope()) 　　{ 　　// 从做为根容器子项的做用域来解析服务 　　var service = scope.Resolv
Autofac学习之三种生命周期：InstancePerLifetimeScope、SingleInstance、InstancePerDependency
小小的熊的博客
08-27 2898
InstancePerLifetimeScope：同一个Lifetime生成的对象是同一个实例 SingleInstance：单例模式，每次调用，都会使用同一个实例化的对象；每次都用同一个对象； InstancePerDependency：默认模式，每次调用，都会重新实例化对象；每次请求都创建一个新的对象； 验证方法实现逻辑：在类的构造函数中，给属性赋值（GUID），通过判断属性值是否一致来判断三种生命周期的效果。 先上图看结果： 1、InstancePerLifetimeScope.
Autofac学习之三种生命周期：InstancePerLifetimeScope、SingleInstance、InstancePerDependency...
weixin_30298497的博客
11-03 232
InstancePerLifetimeScope：同一个Lifetime生成的对象是同一个实例 SingleInstance：单例模式，每次调用，都会使用同一个实例化的对象；每次都用同一个对象； InstancePerDependency：默认模式，每次调用，都会重新实例化对象；每次请求都创建一个新的对象； 验证方法实现逻辑：在类的构造函数中，给属性赋值（GUID），通过判断属性值是否...
【ASP.NET编程知识】.Net Core中使用Autofac替换自带的DI容器的示例.docx
05-15
ASP.NET编程知识，特别是关于.Net Core中的依赖注入（DI）容器的使用，是现代Web开发中的重要组成部分。本文将探讨如何使用Autofac这个流行的第三方DI框架替换.Net Core内置的DI容器。 首先，让我们理解.Net Core...
asp.net core3.1 实战开发（autofact的使用替换框架的IOC实现AOP）
热门推荐
一点一滴
01-05 3万+
原有core 3.1内置了ioc容器和DI注入，有个缺点就算不能够实现AOP，所以使用第三方autofact来代替原有的容器 一：原有core 3.1的容器使用方法 配置服务 public void ConfigureServices(IServiceCollection services) { services.AddSession(); services.AddContro...
ASP.NET Core 5中的依赖注入详解
在ASP.NET Core 5中，依赖注入是一个非常重要的概念，可以帮助我们有效地管理应用程序中的对象依赖关系。 ## 1.1 ASP.NET Core 5概述 ASP.NET Core 5是微软推出的下一代跨平台的Web应用程序开发框架。它集成了更多...
ASP.NET Core 5中的依赖注入和中间件
ASP.NET Core 5简介 ## 1.1 ASP.NET Core 5的概念和架构 ASP.NET Core 5是微软推出的全新一代跨平台Web应用程序开发框架，它具有以下几个核心概念和架构特点： - **跨平台性：** ASP.NET Core 5可以在Windows、...
Autofac依赖注入简要说明(1)——Autofac中的生命周期
吴俊城
10-10 1833
Autofac依赖注入简要说明(1)——Autofac中的生命周期 微软提供了官方的DI容器，有时候它并不能满足对应的需求，这时候就需要使用其他的DI容器，Autofac是.Net生态中一款老牌DI容器，功能齐全性能强劲 本文假设您已经对DI有一定的认识，如果不是很明白可以看看微软的官方文档依赖注入，本文只是讲一讲Autofac的一些常用方法 服务的生命周期 Autofac支持7种生命周期，分别为 Instance Per Dependency 瞬时 Instance Per Dependency和
Autofac创建实例的方法总结
weixin_30378311的博客
09-13 546
1、InstancePerDependency 对每一个依赖或每一次调用创建一个新的唯一的实例。这也是默认的创建实例的方式。 2、InstancePerLifetimeScope 在一个生命周期域中，每一个依赖或调用创建一个单一的共享的实例，且每一个不同的生命周期域，实例是唯一的，不共享的。 3、InstancePerMatchingLifetimeScope 在一...
第三节 Autofac的生命周期
ryancao530的博客
01-28 676
Autofac生命周期 InstancePerDependency SingleInstance InstancePerLifetimeScope InstancePerMatchingLifetimeScope A）InstancePerDependency 在其他容器中也称为“瞬态”或“工厂”。使用per-dependency关系范围，将从服务的每个请求返回唯一的实例。如果没有指定其他选项，这是默认值。 using Autofac; using Autofac.Core; using System;
autofac 实例生命周期
dibeichan3033的博客
09-02 119
转自逆心博客园 autofac 实例生命周期 　　实例生命周期决定在同一个服务的每个请求的实例是如何共享的。 　　当请求一个服务的时候，Autofac会返回一个单例 (single instance作用域), 一个新的对象 (per lifetime作用域) 或者在某种上下文环境中的单例。比如 一个线程 或者一个HTTP请求 (per lifetime 作用域)。 　　这条...
Asp.NetCore3.1 Autofac生命周期
每天学习一点点
11-23 683
autofac生命周期，一共有六种生命周期。通过下面示例展示每种声明周期的作用范围： public void ConfigureContainer(ContainerBuilder containerBuilder) { #region autofac生命周期 //autofac生命周期 六种生命周期 //1.瞬时生命周期:注册之后,每次获取的服务实例都不一样 containe
Autofac官方文档(十五)【生命周期事件】
极客神殿
12-14 775
Autofac公开了在实例生命周期的不同阶段可能被挂钩的事件。 这些在组件注册期间被订阅（或者通过附加到IComponentRegistration接口。) OnActivating OnActivated OnReleaseOnActivatingOnActivating事件在使用组件之前引发。 在这里你可以： 将实例切换为另一个或将其包装在代理中 做属性注入或方法注入 执行
IoC之AutoFac（三）——生命周期
banyongzhan5405的博客
06-05 605
一、Autofac中的生命周期相关概念 　　服务的生命周期：是服务实例在您的应用程序中生存的时间 ，即从原始实例化到释放期间。例如，如果你“新建”了一个实现了IDisposable的对象，然后再调用Dispose（），那么这个对象的生命周期就是从你实例化的时候开始，被释放时结束（或者垃圾回收，如果你没有主动处置它）。 　　服务范围：应用程序中可以与其他使用该服务的组件共享该服务的区域...
Autofac 解析 生命周期作用域
小数点儿的博客
07-17 445
解析 注册完成后，可以从创建的容器或生命周期中解析服务 用Resolve方法实现： var builder = new ContainerBuilder(); builder.RegisterType<MyComponent>().As<IService>(); var container = builder.Build(); using(var scope = container.BeginLifetimeScope()) { var service = scope.Reso
.net core3.1 使用autofac 用来依赖注入
05-27
好的，我可以帮你回答这个问题。下面是使用 Autofac 进行依赖注入的步骤： 1. 在 .NET Core 3.1 的项目中，首先需要安装 Autofac 的 NuGet 包。可以使用 Visual Studio 的 NuGet 包管理器或者使用命令行工具来进行安装。 2. 在应用程序的启动类中，需要创建一个 Autofac 的容器。可以使用以下代码来创建一个容器： ```csharp var builder = new ContainerBuilder(); ``` 3. 注册需要进行依赖注入的服务。可以使用以下代码将一个服务注册到容器中： ```csharp builder.RegisterType<MyService>().As<IMyService>(); ``` 上面的代码将 MyService 类注册为 IMyService 接口的实现。 4. 注册控制器。可以使用以下代码将控制器注册到容器中： ```csharp builder.RegisterControllers(typeof(Startup).Assembly); ``` 上面的代码将应用程序中所有的控制器注册到容器中。 5. 构建容器。可以使用以下代码来构建容器： ```csharp var container = builder.Build(); ``` 6. 在应用程序中使用依赖注入。可以使用以下代码从容器中获取一个服务： ```csharp var service = container.Resolve<IMyService>(); ``` 上面的代码将从容器中获取 IMyService 接口的实现。 以上就是使用 Autofac 进行依赖注入的基本步骤。当然，在实际的应用程序中，可能还需要进行一些高级的配置和使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值