nanoFramework.DependencyInjection 1.1.3

欢迎使用 .NET nanoFramework Dependency Injection 库存储库

为 .NET nanoFramework 提供依赖注入（DI）功能，用于构建类及其依赖关系的控制反转（IoC）。

构建状态

组件	构建状态	NuGet 包
nanoFramework.DependencyInjection

示例

依赖注入示例

依赖注入单元测试

依赖注入容器

依赖注入（DI）容器提供功能并自动化许多涉及对象组合、拦截和生存期管理的任务。它是一个解决和管理工作对象图（Object Graph）的引擎。这些DI容器依赖于编译进所有类中的静态信息。然后使用反射来分析请求的类以及确定所需的依赖项。

此API尽可能接近官方.NET DependencyInjection。异常主要是由于.NET nanoFramework中泛型支持的缺失。

.NET nanoFramework 通用主机提供了创建具有预配置默认值的依赖注入（DI）应用程序容器的便利方法。

用法

服务集合

创建依赖注入容器需要三个基本组件。

• 对象组合 - 定义一组要创建和连接的对象的对象组合。
• 注册服务 - 定义一个 ServiceCollection 的实例，并使用特定的服务生命周期注册对象组合。
• 服务提供者 - 创建一个服务提供者以检索对象。

对象组合

定义一个用于创建和连接的对象组合。

注意：您目前不能将对象定义为 'struct' 或包括数组类型参数（例如，byte[] bytes）作为构造函数参数。这样做会在尝试激活对象时创建空引用异常。

public class RootObject
{
    public int One { get; }
    
    public string Two { get; }

    public ServiceObject ServiceObject { get; protected set; }

    public RootObject(ServiceObject serviceObject)
    {
        ServiceObject = serviceObject;
    }

    // constructor with the most parameters will be used for activation
    public RootObject(ServiceObject serviceObject, int one, string two)
    {
        ServiceObject = serviceObject;
        One = one;
        Two = two;
    }
}

public class ServiceObject
{
    public string Three { get; set; }
}

注册服务

创建一个服务集合，并将单例或瞬态类型服务注册到集合中。

var serviceProvider = new ServiceCollection()
    .AddSingleton(typeof(ServiceObject))
    .AddSingleton(typeof(RootObject))
    .BuildServiceProvider();

服务提供者

创建一个服务提供者以访问或更新对象。

var service = (RootObject)serviceProvider.GetService(typeof(RootObject));
service.ServiceObject.Three = "3";

创建一个作用域服务提供者，提供方便的创建和销毁作用域对象的访问。

var serviceProvider = new ServiceCollection()
    .AddScoped(typeof(typeof(ServiceObject))
    .BuildServiceProvider();

using (var scope = serviceProvider.CreateScope())
{
    var service = scope.ServiceProvider.GetServices(typeof(ServiceObject));
    service.ServiceObject.Three = "3";
}

激活实用工具

可以通过调用对象的构造函数（通过服务提供者解决任何依赖关系）来创建对象的一个实例。自动通过 IServiceProvider 提供的构造函数参数实例化类型，而无需在 DI 容器中注册该类型。

var instance = (RootObject)ActivatorUtilities.CreateInstance(
                        serviceProvider, typeof(RootObject), 1, "2"
                    );

Debug.WriteLine($"One: {instance.One}");
Debug.WriteLine($"Two: {instance.Two}");
Debug.WriteLine($"Three: {instance.ServiceObject.Three}");
Debug.WriteLine($"Name: {instance.ServiceObject.GetType().Name}");

在构建时验证

执行检查以确保可以实际创建已注册到容器的所有服务。这在开发期间特别有用，因为可以快速失败并允许开发者修复问题。默认情况下，构建时验证配置为禁用。

var serviceProvider = new ServiceCollection()
    .AddSingleton(typeof(IServiceObject), typeof(ServiceObject))
    .BuildServiceProvider(new ServiceProviderOptions() { ValidateOnBuild = true });

验证作用域

进行检查，以确保作用域服务从不从根提供者中解决。默认情况下，在构建时验证配置为禁用。

var serviceProvider = new ServiceCollection()
    .AddSingleton(typeof(IServiceObject), typeof(ServiceObject))
    .BuildServiceProvider(new ServiceProviderOptions() { ValidateScopes = true });

示例应用程序容器

using System;
using System.Device.Gpio;
using System.Threading;

using nanoFramework.Logging.Debug;
using nanoFramework.DependencyInjection;

using Microsoft.Extensions.Logging;

nanoFramework.DiApplication
{
    public class Program
    {
        public static void Main()
        {
            var services = ConfigureServices();
            var application = (Application)services.GetRequiredService(typeof(Application));

            application.Run();
        }

        private static ServiceProvider ConfigureServices()
        {
            return new ServiceCollection()
                .AddSingleton(typeof(Application))
                .AddSingleton(typeof(IHardwareService), typeof(HardwareService))
                .AddSingleton(typeof(ILoggerFactory), typeof(DebugLoggerFactory))
                .BuildServiceProvider();
        }
    }

    internal class Application
    {
        private readonly ILogger _logger;
        private readonly IHardwareService _hardware;
        private readonly IServiceProvider _provider;

        public Application(
            IServiceProvider provider,
            IHardwareService hardware, 
            ILoggerFactory loggerFactory)
        {
            _provider = provider;
            _hardware = hardware;
            _logger = loggerFactory.CreateLogger(nameof(Application));

            _logger.LogInformation("Initializing application...");
        }

        public void Run()
        {
            var ledPin = 23; // Set pin number to blink 15=ESP32; 23=STM32

            _logger.LogInformation($"Started blinking led on pin {ledPin}.");
            _hardware.StartBlinking(ledPin);
        }
    }

    internal interface IHardwareService
    {
        public void StartBlinking(int ledPin) { }
    }

    internal class HardwareService : IHardwareService, IDisposable
    {
        private Thread _thread;
        private readonly ILogger _logger;
        private readonly GpioController _gpioController;

        public HardwareService()
        {
            _gpioController = new GpioController();

            var loggerFactory = new DebugLoggerFactory();
            _logger = loggerFactory.CreateLogger(nameof(HardwareService));
        }

        public HardwareService(ILoggerFactory loggerFactory)
        {
            _gpioController = new GpioController();
            _logger = loggerFactory.CreateLogger(nameof(HardwareService));
        }

        public void StartBlinking(int ledPin)
        {
            GpioPin led = _gpioController.OpenPin(ledPin, PinMode.Output);
            led.Write(PinValue.Low);

            _thread = new Thread(() =>
            {
                while (true)
                {
                    Thread.Sleep(2000);

                    led.Write(PinValue.High);
                    _logger.LogInformation("Led status: on");

                    Thread.Sleep(2000);

                    led.Write(PinValue.Low);
                    _logger.LogInformation("Led status: off");
                }
            });

            _thread.Start();
        }

        public void Dispose()
        {
            _gpioController.Dispose();
        }
    }
}

反馈和文档

有关文档、提供反馈、问题以及了解如何贡献的详细信息，请参考主页仓库。

加入我们的 Discord 社区这里。

致谢

贡献者名单可在CONTRIBUTORS中找到。

许可协议

nanoFramework 类库遵循MIT 许可协议。

行为准则

本项目已采用贡献者契约中定义的行为准则，以明确我们社区中预期的行为。有关更多信息，请参阅.NET Foundation 行为准则。

.NET 基金会

本项目由.NET 基金会支持。