Dependency Injection extensions

2026-07-17 23:09:29 +00:00 · 2021-07-10 10:59:27 +03:00
parent 5aaa0d318a
commit 7a764a5929
40 changed files with 1410 additions and 8 deletions
@@ -0,0 +1,14 @@
+namespace System.Extensions.Configuration
+{
+    public sealed class DefaultOptionsManager : IOptionsManager
+    {
+        public T GetOptions<T>() where T : class
+        {
+            return default;
+        }
+
+        public void UpdateOptions<T>(T value) where T : class
+        {
+        }
+    }
+}
@@ -0,0 +1,9 @@
+using Microsoft.Extensions.Options;
+
+namespace System.Extensions.Configuration
+{
+    public interface ILiveOptions<T> : IOptions<T>
+        where T : class
+    {
+    }
+}
@@ -0,0 +1,7 @@
+namespace System.Extensions.Configuration
+{
+    public interface ILiveUpdateableOptions<T> : ILiveOptions<T>, IUpdateableOptions<T>
+        where T : class
+    {
+    }
+}
@@ -0,0 +1,10 @@
+namespace System.Extensions.Configuration
+{
+    public interface IOptionsManager
+    {
+        T GetOptions<T>()
+            where T : class;
+        void UpdateOptions<T>(T value)
+            where T : class;
+    }
+}
@@ -0,0 +1,13 @@
+using Microsoft.Extensions.Options;
+
+namespace System.Extensions.Configuration
+{
+    public interface IUpdateableOptions<out T> : IOptions<T>
+        where T : class
+    {
+        /// <summary>
+        /// Updates the configuration with the current value stored in <see cref="IOptions{TOptions}.Value"/>.
+        /// </summary>
+        void UpdateOption();
+    }
+}
@@ -0,0 +1,27 @@
+using Slim.Resolvers;
+
+namespace System.Extensions.Configuration
+{
+    public sealed class LiveOptionsResolver : IDependencyResolver
+    {
+        private static readonly Type optionsType = typeof(LiveUpdateableOptionsWrapper<>);
+
+        public bool CanResolve(Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ILiveOptions<>))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public object Resolve(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            var typedOptionsType = optionsType.MakeGenericType(type.GetGenericArguments());
+            var configurationManager = serviceProvider.GetService<IOptionsManager>();
+
+            return Activator.CreateInstance(typedOptionsType, configurationManager);
+        }
+    }
+}
@@ -0,0 +1,26 @@
+using Slim.Resolvers;
+
+namespace System.Extensions.Configuration
+{
+    public sealed class LiveUpdateableOptionsResolver : IDependencyResolver
+    {
+        private static readonly Type optionsType = typeof(LiveUpdateableOptionsWrapper<>);
+
+        public bool CanResolve(Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ILiveUpdateableOptions<>))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public object Resolve(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            var typedOptionsType = optionsType.MakeGenericType(type.GetGenericArguments());
+            var configurationManager = serviceProvider.GetService<IOptionsManager>();
+            return Activator.CreateInstance(typedOptionsType, configurationManager);
+        }
+    }
+}
@@ -0,0 +1,31 @@
+using System.Extensions;
+
+namespace System.Extensions.Configuration
+{
+    public sealed class LiveUpdateableOptionsWrapper<T> : ILiveUpdateableOptions<T>
+        where T : class
+    {
+        private readonly IOptionsManager configurationManager;
+
+        private T value;
+
+        public T Value
+        {
+            get
+            {
+                this.value = this.configurationManager.GetOptions<T>();
+                return this.value;
+            }
+        }
+
+        public LiveUpdateableOptionsWrapper(IOptionsManager configurationManager)
+        {
+            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+        }
+
+        public void UpdateOption()
+        {
+            this.configurationManager.UpdateOptions<T>(this.value);
+        }
+    }
+}
@@ -0,0 +1,33 @@
+using Microsoft.Extensions.Options;
+using Slim.Resolvers;
+
+namespace System.Extensions.Configuration
+{
+    public sealed class OptionsResolver : IDependencyResolver
+    {
+        private static readonly Type optionsType = typeof(OptionsWrapper<>);
+        private static readonly Type configurationType = typeof(IOptionsManager);
+
+        public bool CanResolve(Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IOptions<>))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public object Resolve(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            var typedOptionsType = optionsType.MakeGenericType(type.GetGenericArguments());
+            var configurationManager = serviceProvider.GetService<IOptionsManager>();
+            var optionsValue = configurationType
+                .GetMethod(nameof(IOptionsManager.GetOptions))
+                .MakeGenericMethod(type.GetGenericArguments())
+                .Invoke(configurationManager, Array.Empty<object>());
+
+            return Activator.CreateInstance(typedOptionsType, optionsValue);
+        }
+    }
+}
@@ -0,0 +1,32 @@
+using Slim.Resolvers;
+
+namespace System.Extensions.Configuration
+{
+    public sealed class UpdateableOptionsResolver : IDependencyResolver
+    {
+        private static readonly Type optionsType = typeof(UpdateableOptionsWrapper<>);
+        private static readonly Type configurationType = typeof(IOptionsManager);
+
+        public bool CanResolve(Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IUpdateableOptions<>))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public object Resolve(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            var typedOptionsType = optionsType.MakeGenericType(type.GetGenericArguments());
+            var configurationManager = serviceProvider.GetService<IOptionsManager>();
+            var optionsValue = configurationType
+                .GetMethod(nameof(IOptionsManager.GetOptions))
+                .MakeGenericMethod(type.GetGenericArguments())
+                .Invoke(configurationManager, Array.Empty<object>());
+
+            return Activator.CreateInstance(typedOptionsType, configurationManager, optionsValue);
+        }
+    }
+}
@@ -0,0 +1,23 @@
+using System.Extensions;
+
+namespace System.Extensions.Configuration
+{
+    public sealed class UpdateableOptionsWrapper<T> : IUpdateableOptions<T>
+        where T : class
+    {
+        private readonly IOptionsManager configurationManager;
+        
+        public T Value { get; }
+
+        public UpdateableOptionsWrapper(IOptionsManager configurationManager, T options)
+        {
+            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.Value = options;
+        }
+
+        public void UpdateOption()
+        {
+            this.configurationManager.UpdateOptions(this.Value);
+        }
+    }
+}
@@ -0,0 +1,142 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Slim;
+using System.Extensions;
+using System.Extensions.Configuration;
+using System.Http;
+using System.Logging;
+using System.Net.Http;
+
+namespace System.Extensions
+{
+    public static class ServiceManagerExtensions
+    {
+        /// <summary>
+        /// Registers a <see cref="IOptionsManager"/> with the default <see cref="DefaultOptionsManager"/>.
+        /// This call also registers the resolver that resolves <see cref="IUpdateableOptions{T}"/> and <see cref="IOptions{T}"/>.
+        /// </summary>
+        /// <param name="serviceManager"><see cref="IServiceManager"/>.</param>
+        /// <returns>Provided <see cref="IServiceManager"/>.</returns>
+        public static IServiceManager RegisterOptionsManager(this IServiceManager serviceManager)
+        {
+            serviceManager.RegisterSingleton<IOptionsManager, DefaultOptionsManager>();
+            serviceManager.RegisterOptionsResolver();
+
+            return serviceManager;
+        }
+
+        /// <summary>
+        /// Registers a <see cref="IOptionsManager"/>.
+        /// This call also registers the resolver that resolves <see cref="IUpdateableOptions{T}"/> and <see cref="IOptions{T}"/>.
+        /// </summary>
+        /// <typeparam name="T">Implementation of <see cref="IOptionsManager"/>.</typeparam>
+        /// <param name="serviceManager"><see cref="IServiceManager"/>.</param>
+        /// <returns>Provided <see cref="IServiceManager"/>.</returns>
+        public static IServiceManager RegisterOptionsManager<T>(this IServiceManager serviceManager)
+            where T : IOptionsManager
+        {
+            serviceManager.RegisterSingleton<IOptionsManager, T>();
+            serviceManager.RegisterOptionsResolver();
+
+            return serviceManager;
+        }
+
+        /// <summary>
+        /// Registers resolvers for <see cref="IOptions{TOptions}"/> and <see cref="IUpdateableOptions{T}"/>.
+        /// Depends on a <see cref="IOptionsManager"/> in order to properly resolve options.
+        /// </summary>
+        /// <param name="serviceManager"><see cref="IServiceManager"/>.</param>
+        /// <returns><see cref="IServiceManager"/>.</returns>
+        public static IServiceManager RegisterOptionsResolver(this IServiceManager serviceManager)
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterResolver(new OptionsResolver());
+            serviceManager.RegisterResolver(new UpdateableOptionsResolver());
+            serviceManager.RegisterResolver(new LiveOptionsResolver());
+            serviceManager.RegisterResolver(new LiveUpdateableOptionsResolver());
+
+            return serviceManager;
+        }
+
+        /// <summary>
+        /// Registers a <see cref="ILogsWriter"/> with the default <see cref="CVLoggerProvider"/>.
+        /// </summary>
+        /// <typeparam name="TLogsWriter">Implementation of <see cref="ILogsWriter"/>.</typeparam>
+        /// <param name="serviceManager"><see cref="IServiceProducer"/>.</param>
+        /// <returns>Provided <see cref="IServiceProducer"/>.</returns>
+        public static IServiceProducer RegisterLogWriter<TLogsWriter>(this IServiceProducer serviceManager)
+            where TLogsWriter : ILogsWriter
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterSingleton<ILogsWriter, TLogsWriter>();
+            serviceManager.RegisterScoped<ILoggerFactory, LoggerFactory>(sp =>
+            {
+                var factory = new LoggerFactory();
+                factory.AddProvider(new CVLoggerProvider(sp.GetService<ILogsWriter>()));
+                return factory;
+            });
+
+            return serviceManager;
+        }
+
+        /// <summary>
+        /// Registers a <see cref="ILogsWriter"/> with the default <see cref="CVLoggerProvider"/>.
+        /// </summary>
+        /// <typeparam name="TILogsWriter">Interface of <see cref="ILogsWriter"/>.</typeparam>
+        /// <typeparam name="TLogsWriter">Implementation of <see cref="ILogsWriter"/>.</typeparam>
+        /// <param name="serviceManager"><see cref="IServiceProducer"/>.</param>
+        /// <returns>Provided <see cref="IServiceProducer"/>.</returns>
+        public static IServiceProducer RegisterLogWriter<TILogsWriter, TLogsWriter>(this IServiceProducer serviceManager)
+            where TLogsWriter : TILogsWriter
+            where TILogsWriter : class, ILogsWriter
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterSingleton<TILogsWriter, TLogsWriter>();
+            serviceManager.RegisterScoped<ILoggerFactory, LoggerFactory>(sp =>
+            {
+                var factory = new LoggerFactory();
+                factory.AddProvider(new CVLoggerProvider(sp.GetService<TILogsWriter>()));
+                return factory;
+            });
+
+            return serviceManager;
+        }
+
+        public static IServiceManager RegisterLoggerFactory(this IServiceManager serviceManager, Func<Slim.IServiceProvider, ILoggerFactory> loggerFactory)
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterSingleton<ILoggerFactory, ILoggerFactory>(loggerFactory);
+            return serviceManager;
+        }
+
+        public static IServiceManager RegisterDebugLoggerFactory(this IServiceManager serviceManager)
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterLogWriter<ILogsWriter, DebugLogsWriter>();
+            return serviceManager;
+        }
+
+        public static IServiceManager RegisterHttpFactory(this IServiceManager serviceManager)
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterResolver(new HttpClientResolver());
+            return serviceManager;
+        }
+
+        public static IServiceManager RegisterHttpFactory(this IServiceManager serviceManager, Func<Slim.IServiceProvider, Type, HttpMessageHandler> handlerFactory)
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterResolver(
+                new HttpClientResolver()
+                .WithHttpMessageHandlerFactory(handlerFactory));
+            return serviceManager;
+        }
+    }
+}
@@ -0,0 +1,47 @@
+using Slim.Resolvers;
+using System.Linq;
+using System.Net.Http;
+
+namespace System.Http
+{
+    public sealed class HttpClientResolver : IDependencyResolver
+    {
+        private static readonly Type clientType = typeof(HttpClient<>);
+
+        /// <summary>
+        /// Factory method. <see cref="Type"/> parameter of the factory is the scope of <see cref="IHttpClient{TScope}"/>.
+        /// </summary>
+        public Func<Slim.IServiceProvider, Type, HttpMessageHandler> HttpMessageHandlerFactory { get; set; }
+
+        /// <summary>
+        /// Sets the <see cref="HttpMessageHandlerFactory"/>.
+        /// </summary>
+        /// <param name="factory">Factory method. <see cref="Type"/> parameter of the factory is the scope of <see cref="IHttpClient{TScope}"/>.</param>
+        /// <returns></returns>
+        public HttpClientResolver WithHttpMessageHandlerFactory(Func<Slim.IServiceProvider, Type, HttpMessageHandler> factory)
+        {
+            this.HttpMessageHandlerFactory = factory;
+            return this;
+        }
+
+        public bool CanResolve(Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IHttpClient<>))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public object Resolve(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            var typedClientType = clientType.MakeGenericType(type.GetGenericArguments());
+            var handler = this.HttpMessageHandlerFactory?.Invoke(serviceProvider, type.GetGenericArguments().First());
+            var httpClient = handler is null ?
+                Activator.CreateInstance(typedClientType) :
+                Activator.CreateInstance(typedClientType, new object[] { handler });
+            return httpClient;
+        }
+    }
+}
@@ -0,0 +1,44 @@
+using Microsoft.Extensions.Logging;
+using System.Extensions;
+
+namespace System.Logging
+{
+    public sealed class CVLogger : ILogger
+    {
+        private readonly string category;
+        private readonly ICVLoggerProvider cvLoggerProvider;
+
+        public CVLogger(string category, ICVLoggerProvider cvLoggerProvider)
+        {
+            this.category = category;
+            this.cvLoggerProvider = cvLoggerProvider.ThrowIfNull(nameof(cvLoggerProvider));
+        }
+
+        public IDisposable BeginScope<TState>(TState state)
+        {
+            return null;
+        }
+
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            return true;
+        }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        {
+            var message = formatter(state, exception);
+
+            var log = new Log
+            {
+                Exception = exception,
+                LogLevel = logLevel,
+                EventId = eventId.Name,
+                Message = message,
+                Category = category,
+                LogTime = DateTime.Now
+            };
+
+            this.cvLoggerProvider.LogEntry(log);
+        }
+    }
+}
@@ -0,0 +1,44 @@
+using Microsoft.CorrelationVector;
+using Microsoft.Extensions.Logging;
+using System.Extensions;
+
+namespace System.Logging
+{
+    public sealed class CVLoggerProvider : ICVLoggerProvider
+    {
+        private readonly ILogsWriter logsManager;
+        private CorrelationVector correlationVector;
+
+        public CVLoggerProvider(ILogsWriter logsWriter)
+        {
+            this.logsManager = logsWriter.ThrowIfNull(nameof(logsWriter));
+            this.correlationVector = new CorrelationVector();
+        }
+
+        public void LogEntry(Log log)
+        {
+            if (this.correlationVector is not null)
+            {
+                log.CorrelationVector = this.correlationVector.Value.ToString();
+                this.correlationVector.Increment();
+            }
+
+            this.logsManager.WriteLog(log);
+        }
+
+        public ILogger CreateLogger(string categoryName)
+        {
+            if (this.correlationVector is not null)
+            {
+                this.correlationVector = CorrelationVector.Extend(this.correlationVector.ToString());
+            }
+
+            return new CVLogger(categoryName, this);
+        }
+
+        public void Dispose()
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}
@@ -0,0 +1,12 @@
+using System.Diagnostics;
+
+namespace System.Logging
+{
+    public sealed class DebugLogsWriter : ILogsWriter
+    {
+        public void WriteLog(Log log)
+        {
+            Debug.WriteLine($"{log.LogTime} - {log.Category} - {log.EventId} - {log.CorrelationVector} - {log.LogLevel} - {log.Message}{Environment.NewLine}{log.Exception}");
+        }
+    }
+}
@@ -0,0 +1,9 @@
+using Microsoft.Extensions.Logging;
+
+namespace System.Logging
+{
+    public interface ICVLoggerProvider : ILoggerProvider
+    {
+        void LogEntry(Log log);
+    }
+}
@@ -0,0 +1,7 @@
+namespace System.Logging
+{
+    public interface ILogsWriter
+    {
+        void WriteLog(Log log);
+    }
+}
@@ -0,0 +1,50 @@
+using Microsoft.Extensions.Logging;
+using Slim.Resolvers;
+using System.Linq;
+
+namespace System.Windows.Extensions.Logging
+{
+    public sealed class LoggerResolver : IDependencyResolver
+    {
+        public bool CanResolve(Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ILogger<>) ||
+                type == typeof(ILogger))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public object Resolve(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ILogger<>))
+            {
+                return ResolveScopedLogger(serviceProvider, type);
+            }
+            else if (type == typeof(ILogger))
+            {
+                return ResolveLogger(serviceProvider, type);
+            }
+            else
+            {
+                throw new InvalidOperationException($"{nameof(LoggerResolver)} cannot resolve an object of type {type.Name}");
+            }
+        }
+
+        private static object ResolveScopedLogger(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
+            var categoryTypes = type.GetGenericArguments();
+            var createLoggerMethod = typeof(LoggerFactoryExtensions).GetMethods().Where(m => m.IsGenericMethodDefinition && m.Name == nameof(LoggerFactoryExtensions.CreateLogger)).First();
+            return createLoggerMethod.MakeGenericMethod(categoryTypes.First()).Invoke(null, new object[] { loggerFactory });
+        }
+
+        private static object ResolveLogger(Slim.IServiceProvider serviceProvider, Type type)
+        {
+            var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
+            return loggerFactory.CreateLogger(string.Empty);
+        }
+    }
+}
@@ -0,0 +1,15 @@
+using Microsoft.Extensions.Logging;
+
+namespace System.Logging
+{
+    public sealed record Log
+    {
+        public Exception Exception { get; set; }
+        public DateTime LogTime { get; set; }
+        public string Category { get; set; }
+        public string EventId { get; set; }
+        public LogLevel LogLevel { get; set; }
+        public string Message { get; set; }
+        public string CorrelationVector { get; set; }
+    }
+}
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <RootNamespace>System.DependencyInjection</RootNamespace>
+    <PackageLicenseFile>LICENSE</PackageLicenseFile>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <LangVersion>latest</LangVersion>
+    <Version>1.0.0</Version>
+    <Authors>Alexandru Macocian</Authors>
+    <RepositoryUrl>https://github.com/AlexMacocian/SystemExtensions</RepositoryUrl>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\LICENSE" Link="LICENSE">
+      <PackagePath></PackagePath>
+      <Pack>True</Pack>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CorrelationVector" Version="1.0.42" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0" />
+    <PackageReference Include="Slim" Version="1.5.1" />
+    <PackageReference Include="SystemExtensions.NetStandard" Version="1.3.0" />
+  </ItemGroup>
+
+</Project>