Refactore DependencyInjection

src/coverlet.collector/DataCollection/CoverageManager.cs

@@ -22,24 +22,22 @@ internal class CoverageManager
 
         public IReporter[] Reporters { get; }
 
-        public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace, TestPlatformLogger logger, ICoverageWrapper coverageWrapper,
-                               IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator)
+        public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace, ILogger logger,
+            ICoverageWrapper coverageWrapper,
+            IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem,
+            ISourceRootTranslator sourceRootTranslator)
             : this(settings,
-            settings.ReportFormats.Select(format =>
-            {
-                var reporterFactory = new ReporterFactory(format);
-                if (!reporterFactory.IsValidFormat())
-                {
-                    eqtTrace.Warning($"Invalid report format '{format}'");
-                    return null;
-                }
-                else
+                settings.ReportFormats.Select(format =>
                 {
+                    var reporterFactory = new ReporterFactory(format);
+                    if (!reporterFactory.IsValidFormat())
+                    {
+                        eqtTrace.Warning($"Invalid report format '{format}'");
+                        return null;
+                    }
                     return reporterFactory.CreateReporter();
-                }
-            }).Where(r => r != null).ToArray(),
-            new CoverletLogger(eqtTrace, logger),
-            coverageWrapper, instrumentationHelper, fileSystem, sourceRootTranslator)
+                }).Where(r => r != null).ToArray(),
+                logger, coverageWrapper, instrumentationHelper, fileSystem, sourceRootTranslator)
         {
         }
 

src/coverlet.collector/DataCollection/CoverageWrapper.cs

@@ -1,7 +1,6 @@
 using Coverlet.Collector.Utilities.Interfaces;
 using Coverlet.Core;
 using Coverlet.Core.Abstracts;
-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.Abstracts;
 using Coverlet.Core.Helpers;
 using Microsoft.Extensions.DependencyInjection;
@@ -132,7 +131,7 @@ private void OnSessionStart(object sender, SessionStartEventArgs sessionStartEve
                 _serviceProvider = _serviceCollectionFactory(_eqtTrace, _logger, coverletSettings.TestModule).BuildServiceProvider();
 
                 // Get coverage and attachment managers
-                _coverageManager = new CoverageManager(coverletSettings, _eqtTrace, _logger, _coverageWrapper,
+                _coverageManager = new CoverageManager(coverletSettings, _eqtTrace, _serviceProvider.GetRequiredService<ILogger>(), _coverageWrapper,
                                                         _serviceProvider.GetRequiredService<IInstrumentationHelper>(), _serviceProvider.GetRequiredService<IFileSystem>(),
                                                         _serviceProvider.GetRequiredService<ISourceRootTranslator>());
 

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());
+            var 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.msbuild.tasks/BaseTask.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.msbuild.tasks/CoverageResultTask.cs

@@ -6,14 +6,13 @@
 using Coverlet.Core;
 using Coverlet.Core.Abstracts;
 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/InstrumentationTask.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());