当前位置： 首页 > news >正文

ASP.NET Core 中的延迟注入：原理与实践

news 2025/7/14 14:26:58

在软件开发中，依赖注入已成为构建可维护、可测试和可扩展应用程序的核心模式。ASP.NET Core 内置的依赖注入容器为我们管理服务生命周期提供了极大的便利。然而在某些特定场景下，我们可能不希望某个依赖项在宿主对象被创建时立即实例化，而是希望它在首次被使用时才进行实例化。这就是“延迟注入”（Lazy Injection）的概念。

一、延迟注入的原理

延迟注入的核心思想是推迟对象的创建和初始化，直到真正需要使用它的时候。这在以下场景中尤为有用：

  1. 性能优化：当某个依赖项的创建成本很高（例如，需要进行复杂的计算、数据库查询或网络请求），但并非每次宿主对象被使用时都需要该依赖项时，延迟注入可以避免不必要的资源消耗，从而提升应用程序的启动速度和整体性能。
  2. 资源节约：如果某个依赖项会占用大量内存或其他系统资源，并且在应用程序的生命周期中可能只被少数几次使用，那么延迟注入可以帮助我们更有效地管理和节约资源。
  3. 解决循环依赖：在某些复杂的依赖关系图中，可能会出现循环依赖的情况。虽然良好的设计应该避免循环依赖，但在某些不可避免的场景下，延迟注入可以作为一种解决方案，打破循环，允许应用程序正常启动。

在 .NET 中，实现延迟注入最常用的方式是使用 System.Lazy<T> 类。Lazy<T> 是一个泛型类，它包装了一个对象，并确保该对象只在首次访问其 Value 属性时才被创建。Lazy<T> 的构造函数接受一个 Func<T> 委托，这个委托包含了创建被延迟加载对象的逻辑。当 Value 属性首次被访问时，这个委托会被执行，并将其结果缓存起来，后续的访问将直接返回缓存的值。

ASP.NET Core 的内置依赖注入容器本身并不直接支持 Lazy<T> 的自动解析。这意味着你不能直接在构造函数中注入 Lazy<TService>，并期望 DI 容器能够自动为你提供一个 Lazy<TService> 实例。然而，我们可以通过一些简单的配置和模式来实现延迟注入，尤其是在 .NET 8 环境下，其 DI 容器的性能和功能都有所增强，使得这些模式更加高效。

二、在 ASP.NET Core 中实现延迟注入

虽然 ASP.NET Core 的内置 DI 容器不直接支持 Lazy<T> 的自动解析，但我们可以利用其提供的 IServiceProvider 或通过注册工厂方法来实现延迟注入。以下将通过一个具体的代码示例来演示如何在 .NET 8 的 ASP.NET Core 应用程序中实现延迟注入。

假设我们有一个 ExpensiveService，它的创建成本很高，我们希望只在需要时才实例化它：

public interface IExpensiveService
{string GetData();
}public class ExpensiveService : IExpensiveService
{public ExpensiveService(){// 模拟耗时操作Console.WriteLine("ExpensiveService 实例被创建了！");System.Threading.Thread.Sleep(2000); }public string GetData(){return "这是来自 ExpensiveService 的数据。";}
}
2.1 方法一：通过 IServiceProvider 延迟解析

这是最直接的方法。你可以在需要延迟注入的类中注入 IServiceProvider，然后在需要时手动从 IServiceProvider 中解析服务。虽然这在一定程度上引入了服务定位器模式的痕迹，但在某些场景下是可接受的。

首先，在 Program.cs 中注册 ExpensiveService：

// Program.csusing Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;var builder = WebApplication.CreateBuilder(args);// 注册 ExpensiveService
builder.Services.AddTransient<IExpensiveService, ExpensiveService>();// 添加控制器支持
builder.Services.AddControllers();var app = builder.Build();// 配置 HTTP 请求管道
if (app.Environment.IsDevelopment())
{app.UseDeveloperExceptionPage();
}app.UseRouting();app.UseEndpoints(endpoints =>
{endpoints.MapControllers();
});app.Run();

然后，在一个控制器中，你可以这样使用 IServiceProvider 来延迟解析 IExpensiveService：

using Microsoft.AspNetCore.Mvc;
using System;[ApiController]
[Route("[controller]")]
public class HomeController : ControllerBase
{private readonly IServiceProvider _serviceProvider;public HomeController(IServiceProvider serviceProvider){_serviceProvider = serviceProvider;}[HttpGet("lazy-resolve")]public IActionResult LazyResolve(){Console.WriteLine("进入 LazyResolve 方法");// 只有在需要时才解析 ExpensiveServicevar expensiveService = _serviceProvider.GetService<IExpensiveService>();if (expensiveService != null){var data = expensiveService.GetData();return Ok($"延迟解析成功：{data}");}return NotFound("服务未找到。");}[HttpGet("no-lazy-resolve")]public IActionResult NoLazyResolve(){Console.WriteLine("进入 NoLazyResolve 方法");// 不进行延迟解析，如果 ExpensiveService 在构造函数中被注入，则会立即创建return Ok("未进行延迟解析。");}
}

当你访问 /home/lazy-resolve 时，ExpensiveService 的构造函数只会在 GetService<IExpensiveService>() 被调用时才执行。而访问 /home/no-lazy-resolve 则不会触发 ExpensiveService 的实例化（除非 ExpensiveService 被其他非延迟注入的方式所依赖）。

2.2 方法二：注册 Lazy<T> 的工厂方法

这种方法更加优雅，它允许你直接在构造函数中注入 Lazy<TService>，而无需直接暴露 IServiceProvider。你需要手动注册一个工厂方法，告诉 DI 容器如何创建 Lazy<TService> 的实例。

在 Program.cs 中，你可以这样注册 Lazy<IExpensiveService>：

// Program.cs (部分代码)// ...builder.Services.AddTransient<IExpensiveService, ExpensiveService>();// 注册 Lazy<IExpensiveService>
builder.Services.AddTransient(sp => new Lazy<IExpensiveService>(() => sp.GetRequiredService<IExpensiveService>()));// ...

现在，我们可以在控制器中直接注入 Lazy<IExpensiveService>：

using Microsoft.AspNetCore.Mvc;
using System;[ApiController]
[Route("[controller]")]
public class LazyInjectionController : ControllerBase
{private readonly Lazy<IExpensiveService> _lazyExpensiveService;public LazyInjectionController(Lazy<IExpensiveService> lazyExpensiveService){_lazyExpensiveService = lazyExpensiveService;Console.WriteLine("LazyInjectionController 构造函数执行，但 ExpensiveService 尚未创建。");}[HttpGet("lazy-injection")]public IActionResult LazyInjection(){Console.WriteLine("进入 LazyInjection 方法");// 首次访问 .Value 属性时，ExpensiveService 才会被创建var data = _lazyExpensiveService.Value.GetData();return Ok($"延迟注入成功：{data}");}[HttpGet("no-lazy-injection")]public IActionResult NoLazyInjection(){Console.WriteLine("进入 NoLazyInjection 方法");return Ok("未访问延迟注入的服务。");}
}

当你访问 /lazyinjection/lazy-injection 时，ExpensiveService 的构造函数只会在 _lazyExpensiveService.Value 被首次访问时才执行。而访问 /lazyinjection/no-lazy-injection 则不会触发 ExpensiveService 的实例化。

2.3 方法三：使用第三方 DI 容器

一些第三方依赖注入容器，如 Autofac，对 Lazy<T> 有原生支持，使得延迟注入的实现更加简洁。如果你已经在项目中使用或计划使用第三方 DI 容器，这可能是一个更方便的选择。

以 Autofac 为例，你通常只需要注册你的服务，Autofac 会自动处理 Lazy<T> 的解析：

// Startup.cs (Autofac 配置示例)public class Startup
{public ILifetimeScope AutofacContainer { get; private set; }public void ConfigureServices(IServiceCollection services){services.AddControllers();}public void ConfigureContainer(ContainerBuilder builder){builder.RegisterType<ExpensiveService>().As<IExpensiveService>().InstancePerDependency();}public void Configure(IApplicationBuilder app, IWebHostEnvironment env){AutofacContainer = app.ApplicationServices.GetAutofacRoot();if (env.IsDevelopment()){app.UseDeveloperExceptionPage();}app.UseRouting();app.UseEndpoints(endpoints =>{endpoints.MapControllers();});}
}

然后，在控制器中直接注入 Lazy<IExpensiveService> 即可：

using Microsoft.AspNetCore.Mvc;
using System;[ApiController]
[Route("[controller]")]
public class AutofacLazyInjectionController : ControllerBase
{private readonly Lazy<IExpensiveService> _lazyExpensiveService;public AutofacLazyInjectionController(Lazy<IExpensiveService> lazyExpensiveService){_lazyExpensiveService = lazyExpensiveService;Console.WriteLine("AutofacLazyInjectionController 构造函数执行，但 ExpensiveService 尚未创建。");}[HttpGet("autofac-lazy-injection")]public IActionResult AutofacLazyInjection(){Console.WriteLine("进入 AutofacLazyInjection 方法");var data = _lazyExpensiveService.Value.GetData();return Ok($"Autofac 延迟注入成功：{data}");}
}

TIP：使用 Autofac 需要额外的配置步骤来集成到 ASP.NET Core 中，这里仅展示了核心的延迟注入部分。

三、总结

延迟注入是 ASP.NET Core 中一种重要的性能优化和资源管理策略，尤其适用于那些创建成本高昂或不总是需要的服务。通过 System.Lazy<T> 类，我们可以有效地推迟对象的实例化，直到它们真正被使用。虽然 ASP.NET Core 的内置 DI 容器不直接支持 Lazy<T> 的自动解析，但我们可以通过注册工厂方法或注入 IServiceProvider 来实现这一目标。对于更复杂的场景，或者如果你已经在使用第三方 DI 容器，它们通常会提供更简洁的 Lazy<T> 解析支持。在 .NET 8 及其后续版本中，随着框架性能的不断提升，合理地运用延迟注入将有助于构建更高效、响应更迅速的应用程序。

http://www.lryc.cn/news/587301.html

相关文章：

  • 【UE教程/进阶】UE中的指针与引用
  • 应用层协议和JSON的使用
  • gcc 源码阅读---程序入口
  • 面试150 从前序与中序遍历构造二叉树
  • python赤道上空的大气环流剖面图（纬向-高度剖面）
  • Node.js 聊天内容加密解密实战教程（含缓存密钥优化）
  • 【elementUI踩坑记录】解决 el-table 固定列 el-table__fixed 导致部分滚动条无法拖动的问题
  • QT控件命名简写
  • Burp suite的下载安装基础用法（密码喷洒，密码爆破）
  • Linux 系统——管理 MySQL
  • 超市管理系统
  • 问题记录：Fastjson序列化-空值字段处理
  • 数据结构 Map和Set
  • 零基础完全理解视觉语言模型（VLM）：从理论到代码实践
  • ArkUI Inspector工具用法全解析
  • Redis 命令总结
  • react中为啥使用剪头函数
  • Redis技术笔记-从三大缓存问题到高可用集群落地实战
  • 【SpringBoot】注册条件+自动配置原理+自定义starter
  • 通信网络编程5.0——JAVA
  • 【STM32实践篇】：F407 时钟系统
  • [2025CVPR]GNN-ViTCap：用于病理图像分类与描述模型
  • XML实体扩展注入与防御方案
  • [Linux 入门] Linux 引导过程、系统管理与故障处理全解析
  • 强化学习 （11）随机近似
  • opencv python 基本操作
  • WEB渗透
  • 利用DeepSeek证明立体几何题目
  • Maven项目没有Maven工具，IDEA没有识别到该项目是Maven项目怎么办？
  • Prometheus Operator：Kubernetes 监控自动化实践