从小白到大神——.NET下理解注入服务的作用域概念

public classShoppingCart
{
    privatereadonlyInventoryService _inventoryService;
    privatereadonlyPaymentService _paymentService;

    publicShoppingCart()
    {
        _inventoryService =newInventoryService();
        _paymentService =newPaymentService();
    }

    publicvoidCheckout()
    {
        // 检查库存
        _inventoryService.CheckStock();
        // 处理支付
        _paymentService.ProcessPayment();
    }
}

public classShoppingCart
{
    privatereadonlyIInventoryService _inventoryService;
    privatereadonlyIPaymentService _paymentService;

    publicShoppingCart(IInventoryService inventoryService,IPaymentService paymentService)
    {
        _inventoryService = inventoryService;
        _paymentService = paymentService;
    }

    publicvoidCheckout()
    {
        // 检查库存
        _inventoryService.CheckStock();
        // 处理支付
        _paymentService.ProcessPayment();
    }
}

services.AddSingleton<IInventoryService, InventoryService>();

services.AddScoped<IPaymentService, PaymentService>();

services.AddTransient<IEmailService, EmailService>();

public classCounterService
{
    privateint _count =;

    publicintIncrement()
    {
        return++_count;
    }
}
我们在Startup.cs中注册这个服务：
services.AddSingleton<CounterService>();

public class HomeController : Controller
{
    private readonly CounterService _counterService;

    public HomeController(CounterService counterService)
    {
        _counterService = counterService;
    }

    public IActionResult Index()
    {
        ViewBag.Count = _counterService.Increment();
        return View();
    }
}

public classEmailService
{
    publicvoidSendEmail(string to,string subject,string body)
    {
        // 发送邮件的逻辑
    }
}


services.AddTransient<EmailService>();

public classHomeController:Controller
{
    privatereadonlyEmailService _emailService;

    publicHomeController(EmailService emailService)
    {
        _emailService = emailService;
    }

    publicIActionResultSendWelcomeEmail()
    {
        _emailService.SendEmail("webmote@gmail.com","Welcome","Welcome to our website!");
        returnView();
    }
}

using (var scope = serviceProvider.CreateScope())
{
    var scopedService = scope.ServiceProvider.GetRequiredService<ScopedService>();
    // 使用scopedService
}

services.AddScoped<IService>(serviceProvider =>
{
    // 自定义服务创建逻辑
    return new CustomService();
});

public class CustomService : IDisposable
{
    public void Dispose()
    {
        // 自定义服务释放逻辑
    }
}

public classAsyncScopeService
{
    privatestaticreadonlyAsyncLocal<IServiceProvider> _asyncLocal =newAsyncLocal<IServiceProvider>();

    publicstaticIServiceProvider Current
    {
        get=> _asyncLocal.Value;
        set=> _asyncLocal.Value =value;
    }
}

public async Task DoSomethingAsync()
{
    using (var scope = serviceProvider.CreateScope())
    {
        var scopedService = scope.ServiceProvider.GetRequiredService<ScopedService>();
        await scopedService.DoSomethingAsync();
    }
}

public classLoggingAspect:IInterceptor
{
    privatereadonlyILogger _logger;

    publicLoggingAspect(ILogger logger)
    {
        _logger = logger;
    }

    publicvoidIntercept(IInvocation invocation)
    {
        _logger.LogInformation($"Before {invocation.Method.Name}");
        invocation.Proceed();
        _logger.LogInformation($"After {invocation.Method.Name}");
    }
}

public classLoggingAspect:IInterceptor
{
    privatereadonlyIServiceProvider _serviceProvider;

    publicLoggingAspect(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    publicvoidIntercept(IInvocation invocation)
    {
        using(var scope = _serviceProvider.CreateScope())
        {
            var logger = scope.ServiceProvider.GetRequiredService<ILogger>();
            logger.LogInformation($"Before {invocation.Method.Name}");
            invocation.Proceed();
            logger.LogInformation($"After {invocation.Method.Name}");
        }
    }
}

 public classScopeB{
     publicScopeB(ScopeA a)
     {
         A = a;
     }

     publicScopeA A {get;}
}
------------------------------------

var sc =newServiceCollection();
sc.AddScoped<ScopeA>();
sc.AddScoped<ScopeB>();
sc.AddScoped<ScopeC>();
var sp = sc.BuildServiceProvider();

IServiceScope scope2;
ScopeA a2;
using(var scope1 = sp.CreateScope())
{
    var a1 = scope1.ServiceProvider.GetService<ScopeA>();
    var b1 = scope1.ServiceProvider.GetService<ScopeB>();

    scope2 = sp.CreateScope();
    {
        a2 = scope2.ServiceProvider.GetService<ScopeA>();
        var b2 = scope2.ServiceProvider.GetService<ScopeB>();
        var scope3= sp.GetService<IServiceScopeFactory>().CreateScope();

        var same =object.ReferenceEquals(a1, a2);
        Console.WriteLine($"a1==a2? {same}");
        Console.WriteLine($"b1.A==a1? {object.ReferenceEquals(b1.A, a1)}");
        Console.WriteLine($"b1.A==b2.A? {object.ReferenceEquals(b1.A, b2.A)}");
    }

}
var a3 = scope2.ServiceProvider.GetService<ScopeA>();
Console.WriteLine($"a2==a3? {object.ReferenceEquals(a2,a3)}");

a1==a2? False
b1.A==a1? True
b1.A==b2.A? False
a2==a3? True