Dependency Injection extensions

SystemExtensions.NetStandard.DependencyInjection/Logging/CVLogger.cs

@@ -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);
+        }
+    }
+}

SystemExtensions.NetStandard.DependencyInjection/Logging/CVLoggerProvider.cs

@@ -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();
+        }
+    }
+}

SystemExtensions.NetStandard.DependencyInjection/Logging/DebugLogsWriter.cs

@@ -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}");
+        }
+    }
+}

SystemExtensions.NetStandard.DependencyInjection/Logging/ICVLoggerProvider.cs

@@ -0,0 +1,9 @@
+using Microsoft.Extensions.Logging;
+
+namespace System.Logging
+{
+    public interface ICVLoggerProvider : ILoggerProvider
+    {
+        void LogEntry(Log log);
+    }
+}

SystemExtensions.NetStandard.DependencyInjection/Logging/ILogsWriter.cs

@@ -0,0 +1,7 @@
+namespace System.Logging
+{
+    public interface ILogsWriter
+    {
+        void WriteLog(Log log);
+    }
+}

SystemExtensions.NetStandard.DependencyInjection/Logging/LoggerResolver.cs

@@ -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);
+        }
+    }
+}