7. Dependency injection

Register as agreed

Masa It introduces service registration according to the contract , According to the Convention, it is greater than the configuration , Developers don't have to do anything , The framework will automatically complete the registration

Dependent interface

• ISingletonDependency: The registration life cycle is Singleton Service for
• IScopedDependency: The registration life cycle is Scoped Service for
• ITransientDependency: The registration life cycle is Transient Service for
• IAutoFireDependency: Automatic triggering （ And ISingletonDependency、IScopedDependency、ITransientDependency Use a combination of , After the automatic registration of the service is completed, a get service operation is triggered , Just inherit IAutoFireDependency It doesn't work ）

Example ：

``` C#public class StorageOptions : ITransientDependency{  }```

characteristic

IgnoreInjection

Ignore injection , Used to exclude not being automatically injected

• Cascade: Set to true when , The current class and subclasses are no longer automatically registered , Set to false, Only the current class is not automatically registered （ Default false）

Example ：

``` C#public class BaseService : ISingletonDependency{    public static int Count { get; set; } = 0;    public BaseService()    {        Count++;    }    public BaseService(bool isChildren)    {    }}[IgnoreInjection]public class GoodsBaseService : BaseService{    public GoodsBaseService() : base(true)    {    }}public class GoodsService : GoodsBaseService{    public static int GoodsCount { get; set; } = 0;    public GoodsService()    {        GoodsCount++;    }}```

The effect is equivalent to ：services.AddSingleton<BaseService>(); services.AddSingleton<GoodsService>();

Dependency

coordination ISingletonDependency、IScopedDependency、ITransientDependency Use , The implementation service is registered only once

• TryRegister: Set up true Then the service will only be registered if it is not registered , similar IServiceCollection Of TryAdd ... Extension method .

Example ：

``` C#public interface ICache : ISingletonDependency{    void Set(string key, string value);}[Dependency(TryRegister = true)]public class EmptyCache : ICache{    public void Set(string key, string value)    {        throw new NotSupportedException($" Temporary does not support {nameof(Set)} Method ");    }}public class MemoryCache : ICache{    private readonly ConcurrentDictionary<string, Lazy<string>> _dicCache = new();    public void Set(string key, string value)    {        _ = _dicCache.AddOrUpdate        (            key,            k => new Lazy<string>(() => value, LazyThreadSafetyMode.ExecutionAndPublication),            (_, _) => new Lazy<string>(() => value, LazyThreadSafetyMode.ExecutionAndPublication)        ).Value;    }}```

The effect is equivalent to ：services.AddSingleton<ICache, MemoryCache>();

• ReplaceServices: Set up true Then replace the previously registered service , similar IServiceCollection Of Replace ... Extension method .

Example ：

``` C#public interface IEncryptionService : ISingletonDependency{    string MethodName { get; }}[Dependency(ReplaceServices = true)]public class Sha1EncryptionService : IEncryptionService{    public string MethodName => "Sha1";}public class Md5EncryptionService : IEncryptionService{    public string MethodName => "Md5";}```

The effect is equivalent to ：services.AddSingleton<IEncryptionService, Sha1EncryptionService>();

Quick start

• install .Net 6.0

1. New unit test project Assignment.DependencyInjection, choice MSTest, And install Masa.Utils.Extensions.DependencyInjection

   dotnet new xunit -o Assignment.DependencyInjectioncd Assignment.DependencyInjectiondotnet add package Masa.Utils.Extensions.DependencyInjection --version 0.5.0-preview.2

2. The new class StorageOptions

   public class StorageOptions : ITransientDependency{}

3. The new class DITest

   [TestClass]public class DITest{    private IServiceCollection _services;    [TestInitialize]    public void Init()    {        _services = new ServiceCollection();        _services.AddAutoInject();// Perform automatic injection     }    [TestMethod]    public void TestAutoInject()    {        Assert.IsTrue(_services.Any<StorageOptions>(ServiceLifetime.Transient));// Judge StorageOptions Registered successfully , And the life cycle is Transient    }    private IServiceProvider ServiceProvider => _services.BuildServiceProvider();}

summary

If you need to use the automatic registration service according to the contract , Please remember

• According to business needs , Then the following interfaces are implemented in the specified class or interface
  • ISingletonDependency Single case （ Only initialize once after the project is started ）
  • IScopedDependency request （ Initialize only once per request ）
  • ITransientDependency instantaneous （ Each acquisition is initialized ）
• Abstract classes are not automatically registered
• If you have a custom interface IRepository, And you want the interface and the corresponding default implementation class RepositoryBase Will be automatically registered with a lifecycle of Scoped, Interface IRepository Should inherit IScopedDependency
  • If you want to provide by default RepositoryBase Can be replaced by user-defined classes , Should be in RepositoryBase Increase above [Dependency(TryRegister = true)], The user only needs to realize IRepository that will do
  • Or do not change the default RepositoryBase, User implementation IRepository after , And add [Dependency(ReplaceServices = true)]

Source code of this chapter

Assignment07

https://github.com/zhenlei520/MasaFramework.Practice

Open source address

MASA.BuildingBlocks：https://github.com/masastack/MASA.BuildingBlocks

MASA.Contrib：https://github.com/masastack/MASA.Contrib

MASA.Utils：https://github.com/masastack/MASA.Utils

MASA.EShop：https://github.com/masalabs/MASA.EShop

MASA.Blazor：https://github.com/BlazorComponent/MASA.Blazor

If you treat our MASA Framework Interested in , Whether it's code contribution 、 Use 、 carry Issue, Welcome to contact us