当前位置：网站首页>7. Dependency injection

7. Dependency injection

2022-07-25 18:20:00 【MASA team】

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

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

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

The new class StorageOptions

public class StorageOptions : ITransientDependency
{
  
}

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)]