如何在作用域开启时自动解析特定Scoped服务？

方案1：通过DI扩展自动解析标记接口的Scoped服务 #

你可以自定义DI扩展方法，让作用域创建时自动解析所有实现标记接口的Scoped服务，触发构造函数内的事件订阅逻辑。

// 你的标记接口
public interface ISubscriptionService { }

// 服务A实现标记接口
public class ServiceA : ISubscriptionService
{
    public ServiceA(ServiceB serviceB, ServiceC serviceC)
    {
        serviceB.SomeEvent += (sender, args) => 
        {
            serviceC.DoSomething();
        };
    }
}

// DI扩展方法
public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAutoResolvedScoped<TMarker>(this IServiceCollection services)
    {
        var markerType = typeof(TMarker);
        // 自动注册所有实现标记接口的Scoped服务
        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            var targetTypes = assembly.GetTypes()
                .Where(t => markerType.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract);
            foreach (var type in targetTypes)
            {
                services.AddScoped(type);
            }
        }

        // 注册作用域初始化器，触发标记服务的解析
        services.AddScoped(sp =>
        {
            _ = sp.GetServices<TMarker>(); // 解析实例，触发构造函数
            return new ScopeInitializer();
        });

        return services;
    }

    private class ScopeInitializer { }
}

在Program.cs中注册：

builder.Services.AddAutoResolvedScoped<ISubscriptionService>();

方案2：Blazor Server中利用中间件自动解析 #

Blazor Server的每个请求对应一个Scoped作用域，可通过中间件在请求管道中解析标记服务：

public class AutoResolveMiddleware
{
    private readonly RequestDelegate _next;

    public AutoResolveMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 解析所有标记服务，触发订阅逻辑
        _ = context.RequestServices.GetServices<ISubscriptionService>();
        await _next(context);
    }
}

在Program.cs中注册中间件（放在MapBlazorHub之前）：

app.UseMiddleware<AutoResolveMiddleware>();

方案3：Blazor WebAssembly中利用根组件生命周期 #

WASM的根作用域对应应用生命周期，可在App.razor的初始化方法中解析标记服务：

@inject IServiceProvider ServiceProvider

@code {
    protected override void OnInitialized()
    {
        using var scope = ServiceProvider.CreateScope();
        _ = scope.ServiceProvider.GetServices<ISubscriptionService>();
        base.OnInitialized();
    }
}

替代方案：重构事件订阅逻辑（避免强制解析） #

如果不想依赖自动解析，可改用事件总线模式，让服务A在实际被使用时再订阅事件，无需作用域启动时强制实例化：

// 简易事件总线
public interface IEventBus
{
    void Subscribe<TEvent>(Action<TEvent> handler);
    void Publish<TEvent>(TEvent eventData);
}

public class EventBus : IEventBus
{
    private readonly Dictionary<Type, List<Delegate>> _handlers = new();

    public void Subscribe<TEvent>(Action<TEvent> handler)
    {
        var eventType = typeof(TEvent);
        _handlers.TryAdd(eventType, new List<Delegate>());
        _handlers[eventType].Add(handler);
    }

    public void Publish<TEvent>(TEvent eventData)
    {
        if (_handlers.TryGetValue(typeof(TEvent), out var handlers))
        {
            foreach (var handler in handlers.Cast<Action<TEvent>>())
            {
                handler(eventData);
            }
        }
    }
}

服务B通过总线发布事件：

public class ServiceB
{
    private readonly IEventBus _eventBus;

    public ServiceB(IEventBus eventBus) => _eventBus = eventBus;

    public void TriggerEvent() => _eventBus.Publish(new SomeEvent());
}

服务A延迟订阅：

public class ServiceA
{
    private readonly ServiceC _serviceC;
    private bool _subscribed;

    public ServiceA(ServiceC serviceC) => _serviceC = serviceC;

    public void EnsureSubscribed(IEventBus eventBus)
    {
        if (!_subscribed)
        {
            eventBus.Subscribe<SomeEvent>(_ => _serviceC.DoSomething());
            _subscribed = true;
        }
    }
}

内容的提问来源于stack exchange，提问作者onixion