Refactore DependencyInjection (#768)

Refactore DependencyInjection

Author: daveMueller

src/coverlet.collector/DataCollection/CoverageWrapper.cs

@@ -1,7 +1,6 @@
 using Coverlet.Collector.Utilities.Interfaces;
 using Coverlet.Core;
 using Coverlet.Core.Abstractions;
-using Coverlet.Core.Extensions;
 
 namespace Coverlet.Collector.DataCollection
 {

src/coverlet.collector/DataCollection/CoverletCoverageCollector.cs

@@ -5,7 +5,6 @@
 using System.Xml;
 using Coverlet.Collector.Utilities;
 using Coverlet.Collector.Utilities.Interfaces;
-using Coverlet.Core;
 using Coverlet.Core.Abstractions;
 using Coverlet.Core.Helpers;
 using Microsoft.Extensions.DependencyInjection;

src/coverlet.console/Program.cs

@@ -28,13 +28,13 @@ static int Main(string[] args)
             serviceCollection.AddTransient<ILogger, ConsoleLogger>();
             // We need to keep singleton/static semantics
             serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
-            serviceCollection.AddSingleton<ISourceRootTranslator, SourceRootTranslator>(serviceProvider => new SourceRootTranslator(serviceProvider.GetRequiredService<ILogger>(), serviceProvider.GetRequiredService<IFileSystem>()));
+            serviceCollection.AddSingleton<ISourceRootTranslator, SourceRootTranslator>(provider => new SourceRootTranslator(provider.GetRequiredService<ILogger>(), provider.GetRequiredService<IFileSystem>()));
 
-            DependencyInjection.Set(serviceCollection.BuildServiceProvider());
+            ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
 
-            var logger = (ConsoleLogger)DependencyInjection.Current.GetService<ILogger>();
-            var fileSystem = DependencyInjection.Current.GetService<IFileSystem>();
-            var sourceTranslator = DependencyInjection.Current.GetService<ISourceRootTranslator>();
+            var logger = (ConsoleLogger) serviceProvider.GetService<ILogger>();
+            var fileSystem = serviceProvider.GetService<IFileSystem>();
+            var sourceTranslator = serviceProvider.GetService<ISourceRootTranslator>();
 
             var app = new CommandLineApplication();
             app.Name = "coverlet";
@@ -86,7 +86,7 @@ static int Main(string[] args)
                     mergeWith.Value(),
                     useSourceLink.HasValue(),
                     logger,
-                    DependencyInjection.Current.GetService<IInstrumentationHelper>(),
+                    serviceProvider.GetService<IInstrumentationHelper>(),
                     fileSystem,
                     sourceTranslator);
                 coverage.PrepareModules();

src/coverlet.core/DependencyInjection.cs

@@ -0,0 +1,10 @@
+using System;
+using Microsoft.Build.Utilities;
+
+namespace Coverlet.MSbuild.Tasks
+{
+    public abstract class BaseTask : Task
+    {
+        protected static IServiceProvider ServiceProvider { get; set; }
+    }
+}

src/coverlet.core/Extensions/DependencyInjectionExtensions.cs

@@ -6,14 +6,13 @@
 using Coverlet.Core;
 using Coverlet.Core.Abstractions;
 using Coverlet.Core.Enums;
-using Coverlet.Core.Extensions;
 using Coverlet.Core.Reporters;
 using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Coverlet.MSbuild.Tasks
 {
-    public class CoverageResultTask : Task
+    public class CoverageResultTask : BaseTask
     {
         private string _output;
         private string _format;
@@ -83,7 +82,7 @@ public override bool Execute()
             {
                 Console.WriteLine("\nCalculating coverage result...");
 
-                IFileSystem fileSystem = DependencyInjection.Current.GetService<IFileSystem>();
+                IFileSystem fileSystem = ServiceProvider.GetService<IFileSystem>();
                 if (InstrumenterState is null || !fileSystem.Exists(InstrumenterState.ItemSpec))
                 {
                     _logger.LogError("Result of instrumentation task not found");
@@ -93,11 +92,11 @@ public override bool Execute()
                 Coverage coverage = null;
                 using (Stream instrumenterStateStream = fileSystem.NewFileStream(InstrumenterState.ItemSpec, FileMode.Open))
                 {
-                    var instrumentationHelper = DependencyInjection.Current.GetService<IInstrumentationHelper>();
+                    var instrumentationHelper = ServiceProvider.GetService<IInstrumentationHelper>();
                     // Task.Log is teared down after a task and thus the new MSBuildLogger must be passed to the InstrumentationHelper
                     // https://github.com/microsoft/msbuild/issues/5153
                     instrumentationHelper.SetLogger(_logger);
-                    coverage = new Coverage(CoveragePrepareResult.Deserialize(instrumenterStateStream), this._logger, DependencyInjection.Current.GetService<IInstrumentationHelper>(), fileSystem);
+                    coverage = new Coverage(CoveragePrepareResult.Deserialize(instrumenterStateStream), this._logger, ServiceProvider.GetService<IInstrumentationHelper>(), fileSystem);
                 }
 
                 try
@@ -144,7 +143,7 @@ public override bool Execute()
                                                                 _output,
                                                                 reporter,
                                                                 fileSystem,
-                                                                DependencyInjection.Current.GetService<IConsole>(),
+                                                                ServiceProvider.GetService<IConsole>(),
                                                                 result);
                         writer.WriteReport();
                     }

src/coverlet.msbuild.tasks/BaseTask.cs

@@ -12,7 +12,7 @@
 
 namespace Coverlet.MSbuild.Tasks
 {
-    public class InstrumentationTask : Task
+    public class InstrumentationTask : BaseTask
     {
         private string _path;
         private string _include;
@@ -132,7 +132,7 @@ public override bool Execute()
             // We need to keep singleton/static semantics
             serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
 
-            DependencyInjection.Set(serviceCollection.BuildServiceProvider());
+            ServiceProvider = serviceCollection.BuildServiceProvider();
 
             try
             {
@@ -141,7 +141,7 @@ public override bool Execute()
                 var excludeFilters = _exclude?.Split(',');
                 var excludedSourceFiles = _excludeByFile?.Split(',');
                 var excludeAttributes = _excludeByAttribute?.Split(',');
-                var fileSystem = DependencyInjection.Current.GetService<IFileSystem>();
+                var fileSystem = ServiceProvider.GetService<IFileSystem>();
 
                 Coverage coverage = new Coverage(_path,
                     includeFilters,
@@ -154,9 +154,9 @@ public override bool Execute()
                     _mergeWith,
                     _useSourceLink,
                     _logger,
-                    DependencyInjection.Current.GetService<IInstrumentationHelper>(),
+                    ServiceProvider.GetService<IInstrumentationHelper>(),
                     fileSystem,
-                    DependencyInjection.Current.GetService<ISourceRootTranslator>());
+                    ServiceProvider.GetService<ISourceRootTranslator>());
 
                 CoveragePrepareResult prepareResult = coverage.PrepareModules();
                 InstrumenterState = new TaskItem(System.IO.Path.GetTempFileName());