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

发布于：2025-07-15 ⋅ 阅读:(21) ⋅ 点赞:(0)

在软件开发中，依赖注入已成为构建可维护、可测试和可扩展应用程序的核心模式。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.cs

using 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 方法");
        // 只有在需要时才解析 ExpensiveService
        var 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 及其后续版本中，随着框架性能的不断提升，合理地运用延迟注入将有助于构建更高效、响应更迅速的应用程序。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布