Refactore DependencyInjection

src/coverlet.collector/DataCollection/CoverageManager.cs

@@ -22,34 +22,33 @@ internal class CoverageManager
 
         public IReporter[] Reporters { get; }
 
-        public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace, TestPlatformLogger logger, ICoverageWrapper coverageWrapper)
+        public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace, ILogger logger, ICoverageWrapper coverageWrapper, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem)
             : 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 =>
                 {
-                    return reporterFactory.CreateReporter();
-                }
-            }).Where(r => r != null).ToArray(),
-            new CoverletLogger(eqtTrace, logger),
-            coverageWrapper)
+                    var reporterFactory = new ReporterFactory(format);
+                    if (!reporterFactory.IsValidFormat())
+                    {
+                        eqtTrace.Warning($"Invalid report format '{format}'");
+                        return null;
+                    }
+                    else
+                    {
+                        return reporterFactory.CreateReporter();
+                    }
+                }).Where(r => r != null).ToArray(),
+                logger, coverageWrapper, instrumentationHelper, fileSystem)
         {
         }
 
-        public CoverageManager(CoverletSettings settings, IReporter[] reporters, ILogger logger, ICoverageWrapper coverageWrapper)
+        public CoverageManager(CoverletSettings settings, IReporter[] reporters, ILogger logger, ICoverageWrapper coverageWrapper, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem)
         {
             // Store input vars
             Reporters = reporters;
             _coverageWrapper = coverageWrapper;
 
             // Coverage object
-            _coverage = _coverageWrapper.CreateCoverage(settings, logger);
+            _coverage = _coverageWrapper.CreateCoverage(settings, logger, instrumentationHelper, fileSystem);
         }
 
         /// <summary>

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
 {
@@ -16,7 +15,7 @@ internal class CoverageWrapper : ICoverageWrapper
         /// <param name="settings">Coverlet settings</param>
         /// <param name="coverletLogger">Coverlet logger</param>
         /// <returns>Coverage object</returns>
-        public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger)
+        public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem)
         {
             return new Coverage(
                 settings.TestModule,
@@ -30,8 +29,8 @@ public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger
                 settings.MergeWith,
                 settings.UseSourceLink,
                 coverletLogger,
-                DependencyInjection.Current.GetService<IInstrumentationHelper>(),
-                DependencyInjection.Current.GetService<IFileSystem>());
+                instrumentationHelper,
+                fileSystem);
         }
 
         /// <summary>

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;
@@ -29,6 +28,7 @@ public class CoverletCoverageCollector : DataCollector
         private CoverageManager _coverageManager;
         private ICoverageWrapper _coverageWrapper;
         private ICountDownEventFactory _countDownEventFactory;
+        private IServiceProvider _serviceProvider;
 
         public CoverletCoverageCollector() : this(new TestPlatformEqtTrace(), new CoverageWrapper(), new CollectorCountdownEventFactory())
         {
@@ -79,7 +79,7 @@ public override void Initialize(
             _dataSink = dataSink;
             _dataCollectionContext = environmentContext.SessionDataCollectionContext;
             _logger = new TestPlatformLogger(logger, _dataCollectionContext);
-            DependencyInjection.Set(GetServiceProvider(_eqtTrace, _logger));
+            _serviceProvider = GetServiceProvider(_eqtTrace, _logger);
 
             // Register events
             _events.SessionStart += OnSessionStart;
@@ -124,9 +124,12 @@ private void OnSessionStart(object sender, SessionStartEventArgs sessionStartEve
                 IEnumerable<string> testModules = this.GetTestModules(sessionStartEventArgs);
                 var coverletSettingsParser = new CoverletSettingsParser(_eqtTrace);
                 CoverletSettings coverletSettings = coverletSettingsParser.Parse(_configurationElement, testModules);
+                IInstrumentationHelper instrumentationHelper = _serviceProvider.GetService<IInstrumentationHelper>();
+                IFileSystem fileSystem = _serviceProvider.GetService<IFileSystem>();
+                ILogger logger = _serviceProvider.GetService<ILogger>();
 
                 // Get coverage and attachment managers
-                _coverageManager = new CoverageManager(coverletSettings, _eqtTrace, _logger, _coverageWrapper);
+                _coverageManager = new CoverageManager(coverletSettings, _eqtTrace, logger, _coverageWrapper, instrumentationHelper, fileSystem);
 
                 // Instrument modules
                 _coverageManager.InstrumentModules();

src/coverlet.collector/Utilities/Interfaces/ICoverageWrapper.cs

@@ -16,7 +16,7 @@ internal interface ICoverageWrapper
         /// <param name="settings">Coverlet settings</param>
         /// <param name="coverletLogger">Coverlet logger</param>
         /// <returns>Coverage object</returns>
-        Coverage CreateCoverage(CoverletSettings settings, ILogger logger);
+        Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem);
 
         /// <summary>
         /// Gets the coverage result from provided coverage object

src/coverlet.console/Program.cs

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

src/coverlet.msbuild.tasks/CoverageResultTask.cs

@@ -6,10 +6,11 @@
 using Coverlet.Core;
 using Coverlet.Core.Abstracts;
 using Coverlet.Core.Enums;
-using Coverlet.Core.Extensions;
 using Coverlet.Core.Reporters;
+using coverlet.msbuild.tasks;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Coverlet.MSbuild.Tasks
 {
@@ -83,7 +84,7 @@ public override bool Execute()
             {
                 Console.WriteLine("\nCalculating coverage result...");
 
-                IFileSystem fileSystem = DependencyInjection.Current.GetService<IFileSystem>();
+                IFileSystem fileSystem = Services.ServiceProvider.GetService<IFileSystem>();
                 if (InstrumenterState is null || !fileSystem.Exists(InstrumenterState.ItemSpec))
                 {
                     _logger.LogError("Result of instrumentation task not found");
@@ -93,11 +94,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 = Services.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, Services.ServiceProvider.GetService<IInstrumentationHelper>(), fileSystem);
                 }
 
                 try
@@ -144,7 +145,7 @@ public override bool Execute()
                                                                 _output,
                                                                 reporter,
                                                                 fileSystem,
-                                                                DependencyInjection.Current.GetService<IConsole>(),
+                                                                Services.ServiceProvider.GetService<IConsole>(),
                                                                 result);
                         writer.WriteReport();
                     }

src/coverlet.msbuild.tasks/InstrumentationTask.cs

@@ -5,6 +5,7 @@
 using Coverlet.Core;
 using Coverlet.Core.Abstracts;
 using Coverlet.Core.Helpers;
+using coverlet.msbuild.tasks;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
 using Microsoft.Extensions.DependencyInjection;
@@ -131,7 +132,7 @@ public override bool Execute()
             // We need to keep singleton/static semantics
             serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
 
-            DependencyInjection.Set(serviceCollection.BuildServiceProvider());
+            Services.ServiceProvider = serviceCollection.BuildServiceProvider();
 
             try
             {
@@ -140,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 = Services.ServiceProvider.GetService<IFileSystem>();
 
                 Coverage coverage = new Coverage(_path,
                     includeFilters,
@@ -153,7 +154,7 @@ public override bool Execute()
                     _mergeWith,
                     _useSourceLink,
                     _logger,
-                    DependencyInjection.Current.GetService<IInstrumentationHelper>(),
+                    Services.ServiceProvider.GetService<IInstrumentationHelper>(),
                     fileSystem);
 
                 CoveragePrepareResult prepareResult = coverage.PrepareModules();

src/coverlet.msbuild.tasks/Services.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace coverlet.msbuild.tasks
+{
+    internal static class Services
+    {
+        public static IServiceProvider ServiceProvider { get; set; }
+    }
+}

test/coverlet.collector.tests/CoverletCoverageDataCollectorTests.cs

@@ -60,7 +60,7 @@ public void OnSessionStartShouldInitializeCoverageWithCorrectCoverletSettings()
 
             _mockDataColectionEvents.Raise(x => x.SessionStart += null, new SessionStartEventArgs(sessionStartProperties));
 
-            _mockCoverageWrapper.Verify(x => x.CreateCoverage(It.Is<CoverletSettings>(y => string.Equals(y.TestModule, "abc.dll")), It.IsAny<ILogger>()), Times.Once);
+            _mockCoverageWrapper.Verify(x => x.CreateCoverage(It.Is<CoverletSettings>(y => string.Equals(y.TestModule, "abc.dll")), It.IsAny<ILogger>(), It.IsAny<IInstrumentationHelper>(), It.IsAny<IFileSystem>()), Times.Once);
         }
 
         [Fact]
@@ -74,14 +74,14 @@ public void OnSessionStartShouldPrepareModulesForCoverage()
                     null,
                     _context);
             IDictionary<string, object> sessionStartProperties = new Dictionary<string, object>();
-            Coverage coverage = new Coverage("abc.dll", null, null, null, null, null, true, true, "abc.json", true, It.IsAny<ILogger>(), DependencyInjection.Current.GetService<IInstrumentationHelper>(), DependencyInjection.Current.GetService<IFileSystem>());
+            Coverage coverage = new Coverage("abc.dll", null, null, null, null, null, true, true, "abc.json", true, It.IsAny<ILogger>(), new Mock<IInstrumentationHelper>().Object, new Mock<IFileSystem>().Object);
 
             sessionStartProperties.Add("TestSources", new List<string> { "abc.dll" });
-            _mockCoverageWrapper.Setup(x => x.CreateCoverage(It.IsAny<CoverletSettings>(), It.IsAny<ILogger>())).Returns(coverage);
+            _mockCoverageWrapper.Setup(x => x.CreateCoverage(It.IsAny<CoverletSettings>(), It.IsAny<ILogger>(), new Mock<IInstrumentationHelper>().Object, new Mock<IFileSystem>().Object)).Returns(coverage);
 
             _mockDataColectionEvents.Raise(x => x.SessionStart += null, new SessionStartEventArgs(sessionStartProperties));
 
-            _mockCoverageWrapper.Verify(x => x.CreateCoverage(It.Is<CoverletSettings>(y => y.TestModule.Contains("abc.dll")), It.IsAny<ILogger>()), Times.Once);
+            _mockCoverageWrapper.Verify(x => x.CreateCoverage(It.Is<CoverletSettings>(y => y.TestModule.Contains("abc.dll")), It.IsAny<ILogger>(), It.IsAny<IInstrumentationHelper>(), It.IsAny<IFileSystem>()), Times.Once);
             _mockCoverageWrapper.Verify(x => x.PrepareModules(It.IsAny<Coverage>()), Times.Once);
         }