refactor: replace Confuser.Core.ILogger with Microsoft.Extensions.Logging.ILogger (#64)

Complete migration from the custom 13-method ILogger interface to the
standard M.E.L ILogger abstraction across all projects.

- Change ConfuserContext.Logger and ConfuserParameters.Logger to M.E.L ILogger
- Convert all ~80 call sites: Debug→LogDebug, Info→LogInformation,
  Warn→LogWarning, Error→LogError, *Exception→swap parameter order
- Rewrite MSBuildLogger as MSBuildMelLogger implementing M.E.L ILogger
- Rewrite XUnitLogger implementing M.E.L ILogger + IProgressReporter
- Remove MelLoggerAdapter (no longer needed — M.E.L is the native type)
- Delete Confuser.Core.ILogger, NullLogger (replaced by M.E.L NullLogger)
- Add test-results/ and coverage/ to .gitignore

Author: RandomCrocodile

.gitignore

@@ -39,4 +39,8 @@ packages/
 gh-pages/
 
 .idea/
-**/*out*
+**/*out*
+
+# Local CI artifacts
+test-results/
+coverage/

Confuser.CLI/Program.cs

@@ -222,7 +222,7 @@ static int RunProject(ConfuserParameters parameters, bool quiet, int verbosity)
 			var melLogger = loggerFactory.CreateLogger("ConfuserEx");
 
 			var progressReporter = new ConsoleProgressReporter();
-			parameters.Logger = new MelLoggerAdapter(melLogger);
+			parameters.Logger = melLogger;
 			parameters.ProgressReporter = progressReporter;
 
 			if (OperatingSystem.IsWindows())

Confuser.Core/ConfuserContext.cs

@@ -4,6 +4,7 @@
 using Confuser.Core.Project;
 using dnlib.DotNet;
 using dnlib.DotNet.Writer;
+using Microsoft.Extensions.Logging;
 
 namespace Confuser.Core {
 	/// <summary>
@@ -18,7 +19,7 @@ public class ConfuserContext {
 		///     Gets the logger used for logging events.
 		/// </summary>
 		/// <value>The logger.</value>
-		public ILogger Logger { get; internal set; }
+		public Microsoft.Extensions.Logging.ILogger Logger { get; internal set; }
 
 		/// <summary>
 		///     Gets the progress reporter used for reporting protection progress.

Confuser.Core/ConfuserEngine.cs

@@ -10,6 +10,7 @@
 using dnlib.DotNet;
 using dnlib.DotNet.Emit;
 using dnlib.DotNet.Writer;
+using Microsoft.Extensions.Logging;
 using Microsoft.Win32;
 using CopyrightAttribute = System.Reflection.AssemblyCopyrightAttribute;
 using InformationalAttribute = System.Reflection.AssemblyInformationalVersionAttribute;
@@ -108,7 +109,7 @@ static void RunInternal(ConfuserParameters parameters, CancellationToken token)
 					var modulePath = Path.Combine(context.BaseDirectory, firstModule.Path);
 					foreach (var runtimePath in DotNetCorePathResolver.ResolveRuntimePaths(modulePath, context.Logger)) {
 						asmResolver.PostSearchPaths.Add(runtimePath);
-						context.Logger.DebugFormat("Auto-detected .NET runtime path: {0}", runtimePath);
+						context.Logger.LogDebug("Auto-detected .NET runtime path: {0}", runtimePath);
 					}
 				}
 
@@ -117,25 +118,25 @@ static void RunInternal(ConfuserParameters parameters, CancellationToken token)
 				Marker marker = parameters.GetMarker();
 
 				// 2. Discover plugins
-				context.Logger.Debug("Discovering plugins...");
+				context.Logger.LogDebug("Discovering plugins...");
 
 				IList<Protection> prots;
 				IList<Packer> packers;
 				IList<ConfuserComponent> components;
 				parameters.GetPluginDiscovery().GetPlugins(context, out prots, out packers, out components);
 
-				context.Logger.InfoFormat("Discovered {0} protections, {1} packers.", prots.Count, packers.Count);
+				context.Logger.LogInformation("Discovered {0} protections, {1} packers.", prots.Count, packers.Count);
 
 				context.CheckCancellation();
 
 				// 3. Resolve dependency
-				context.Logger.Debug("Resolving component dependency...");
+				context.Logger.LogDebug("Resolving component dependency...");
 				try {
 					var resolver = new DependencyResolver(prots);
 					prots = resolver.SortDependency();
 				}
 				catch (CircularDependencyException ex) {
-					context.Logger.ErrorException("", ex);
+					context.Logger.LogError(ex, "");
 					throw new ConfuserException(ex);
 				}
 
@@ -148,7 +149,7 @@ static void RunInternal(ConfuserParameters parameters, CancellationToken token)
 				context.CheckCancellation();
 
 				// 4. Load modules
-				context.Logger.Info("Loading input modules...");
+				context.Logger.LogInformation("Loading input modules...");
 				marker.Initialize(prots, packers);
 				MarkerResult markings = marker.MarkProject(context.Project, context);
 				context.Modules = new ModuleSorter(markings.Modules).Sort().ToList().AsReadOnly();
@@ -163,13 +164,13 @@ static void RunInternal(ConfuserParameters parameters, CancellationToken token)
 				context.CheckCancellation();
 
 				// 5. Initialize components
-				context.Logger.Info("Initializing...");
+				context.Logger.LogInformation("Initializing...");
 				foreach (ConfuserComponent comp in components) {
 					try {
 						comp.Initialize(context);
 					}
 					catch (Exception ex) {
-						context.Logger.ErrorException("Error occurred during initialization of '" + comp.Name + "'.", ex);
+						context.Logger.LogError(ex, "Error occurred during initialization of '" + comp.Name + "'.");
 						throw new ConfuserException(ex);
 					}
 					context.CheckCancellation();
@@ -178,7 +179,7 @@ static void RunInternal(ConfuserParameters parameters, CancellationToken token)
 				context.CheckCancellation();
 
 				// 6. Build pipeline
-				context.Logger.Debug("Building pipeline...");
+				context.Logger.LogDebug("Building pipeline...");
 				var pipeline = new ProtectionPipeline();
 				context.Pipeline = pipeline;
 				foreach (ConfuserComponent comp in components) {
@@ -193,28 +194,28 @@ static void RunInternal(ConfuserParameters parameters, CancellationToken token)
 				ok = true;
 			}
 			catch (AssemblyResolveException ex) {
-				context.Logger.ErrorException("Failed to resolve an assembly, check if all dependencies are present in the correct version.", ex);
+				context.Logger.LogError(ex, "Failed to resolve an assembly, check if all dependencies are present in the correct version.");
 				PrintEnvironmentInfo(context);
 			}
 			catch (TypeResolveException ex) {
-				context.Logger.ErrorException("Failed to resolve a type, check if all dependencies are present in the correct version.", ex);
+				context.Logger.LogError(ex, "Failed to resolve a type, check if all dependencies are present in the correct version.");
 				PrintEnvironmentInfo(context);
 			}
 			catch (MemberRefResolveException ex) {
-				context.Logger.ErrorException("Failed to resolve a member, check if all dependencies are present in the correct version.", ex);
+				context.Logger.LogError(ex, "Failed to resolve a member, check if all dependencies are present in the correct version.");
 				PrintEnvironmentInfo(context);
 			}
 			catch (IOException ex) {
-				context.Logger.ErrorException("An IO error occurred, check if all input/output locations are readable/writable.", ex);
+				context.Logger.LogError(ex, "An IO error occurred, check if all input/output locations are readable/writable.");
 			}
 			catch (OperationCanceledException) {
-				context.Logger.Error("Operation cancelled.");
+				context.Logger.LogError("Operation cancelled.");
 			}
 			catch (ConfuserException) {
 				// Exception is already handled/logged, so just ignore and report failure
 			}
 			catch (Exception ex) {
-				context.Logger.ErrorException("Unknown error occurred.", ex);
+				context.Logger.LogError(ex, "Unknown error occurred.");
 			}
 			finally {
 				if (context.Resolver != null)
@@ -269,27 +270,27 @@ static void RunPipeline(ProtectionPipeline pipeline, ConfuserContext context) {
 			pipeline.ExecuteStage(PipelineStage.SaveModules, SaveModules, () => getAllDefs(), context);
 
 			if (!context.PackerInitiated)
-				context.Logger.Info("Done.");
+				context.Logger.LogInformation("Done.");
 		}
 
 		static void Inspection(ConfuserContext context) {
-			context.Logger.Info("Resolving dependencies...");
+			context.Logger.LogInformation("Resolving dependencies...");
 			foreach (var dependency in context.Modules
 											  .SelectMany(module => module.GetAssemblyRefs().Select(asmRef => Tuple.Create(asmRef, module)))) {
 				var resolved = context.Resolver.Resolve(dependency.Item1, dependency.Item2);
 				if (resolved == null)
-					context.Logger.WarnFormat("Failed to resolve dependency '{0}' of '{1}'. Some protections may not work correctly.",
+					context.Logger.LogWarning("Failed to resolve dependency '{0}' of '{1}'. Some protections may not work correctly.",
 						dependency.Item1.FullName, dependency.Item2.Name);
 			}
 
-			context.Logger.Debug("Checking Strong Name...");
+			context.Logger.LogDebug("Checking Strong Name...");
 			foreach (var module in context.Modules) {
 				CheckStrongName(context, module);
 			}
 
 			var marker = context.Registry.GetService<IMarkerService>();
 
-			context.Logger.Debug("Creating global .cctors...");
+			context.Logger.LogDebug("Creating global .cctors...");
 			foreach (ModuleDefMD module in context.Modules) {
 				TypeDef modType = module.GlobalType;
 				if (modType == null) {
@@ -317,12 +318,12 @@ static void CheckStrongName(ConfuserContext context, ModuleDef module) {
 			bool isKeyProvided = snKey != null || (snDelaySign && snPubKeyBytes != null);
 
 			if (!isKeyProvided && moduleIsSignedOrDelayedSigned)
-				context.Logger.WarnFormat("[{0}] SN Key or SN public Key is not provided for a signed module, the output may not be working.", module.Name);
+				context.Logger.LogWarning("[{0}] SN Key or SN public Key is not provided for a signed module, the output may not be working.", module.Name);
 			else if (isKeyProvided && !moduleIsSignedOrDelayedSigned)
-				context.Logger.WarnFormat("[{0}] SN Key or SN public Key is provided for an unsigned module, the output may not be working.", module.Name);
+				context.Logger.LogWarning("[{0}] SN Key or SN public Key is provided for an unsigned module, the output may not be working.", module.Name);
 			else if (snPubKeyBytes != null && moduleIsSignedOrDelayedSigned &&
 					 !module.Assembly.PublicKey.Data.SequenceEqual(snPubKeyBytes))
-				context.Logger.WarnFormat("[{0}] Provided SN public Key and signed module's public key do not match, the output may not be working.",
+				context.Logger.LogWarning("[{0}] Provided SN public Key and signed module's public key do not match, the output may not be working.",
 					module.Name);
 		}
 
@@ -339,7 +340,7 @@ static void CopyPEHeaders(PEHeadersOptions writerOptions, ModuleDefMD module) {
 		}
 
 		static void BeginModule(ConfuserContext context) {
-			context.Logger.InfoFormat("Processing module '{0}'...", context.CurrentModule.Name);
+			context.Logger.LogInformation("Processing module '{0}'...", context.CurrentModule.Name);
 
 			context.CurrentModuleWriterOptions = new ModuleWriterOptions(context.CurrentModule);
 			CopyPEHeaders(context.CurrentModuleWriterOptions.PEHeadersOptions, context.CurrentModule);
@@ -394,7 +395,7 @@ static void EndModule(ConfuserContext context) {
 					output = Path.Combine(context.BaseDirectory, output);
 				string relativeOutput = Utils.GetRelativePath(output, context.BaseDirectory);
 				if (relativeOutput is null) {
-					context.Logger.WarnFormat("Input file is not inside the base directory. Relative path can't be created. Placing file into output root." +
+					context.Logger.LogWarning("Input file is not inside the base directory. Relative path can't be created. Placing file into output root." +
 						Environment.NewLine + "Responsible file is: {0}", output);
 					output = Path.GetFileName(output);
 				}
@@ -409,7 +410,7 @@ static void EndModule(ConfuserContext context) {
 		}
 
 		static void WriteModule(ConfuserContext context) {
-			context.Logger.InfoFormat("Writing module '{0}'...", context.CurrentModule.Name);
+			context.Logger.LogInformation("Writing module '{0}'...", context.CurrentModule.Name);
 
 			MemoryStream pdb = null, output = new MemoryStream();
 
@@ -431,7 +432,7 @@ static void WriteModule(ConfuserContext context) {
 		}
 
 		static void Debug(ConfuserContext context) {
-			context.Logger.Info("Finalizing...");
+			context.Logger.LogInformation("Finalizing...");
 			if (!context.Project.Debug)
 				return;
 			for (int i = 0; i < context.OutputModules.Count; i++) {
@@ -447,7 +448,7 @@ static void Debug(ConfuserContext context) {
 
 		static void Pack(ConfuserContext context) {
 			if (context.Packer != null) {
-				context.Logger.Info("Packing...");
+				context.Logger.LogInformation("Packing...");
 				context.Packer.Pack(context, new ProtectionParameters(context.Packer, context.Modules.OfType<IDnlibDef>().ToList()));
 			}
 		}
@@ -459,7 +460,7 @@ static void SaveModules(ConfuserContext context) {
 				string dir = Path.GetDirectoryName(path);
 				if (!Directory.Exists(dir))
 					Directory.CreateDirectory(dir);
-				context.Logger.DebugFormat("Saving to '{0}'...", path);
+				context.Logger.LogDebug("Saving to '{0}'...", path);
 				File.WriteAllBytes(path, context.OutputModules[i]);
 			}
 		}
@@ -470,13 +471,13 @@ static void SaveModules(ConfuserContext context) {
 		/// <param name="context">The working context.</param>
 		static void PrintInfo(ConfuserContext context) {
 			if (context.PackerInitiated) {
-				context.Logger.Info("Protecting packer stub...");
+				context.Logger.LogInformation("Protecting packer stub...");
 			}
 			else {
-				context.Logger.InfoFormat("{0} {1}", Version, Copyright);
+				context.Logger.LogInformation("{0} {1}", Version, Copyright);
 
 				Type mono = Type.GetType("Mono.Runtime");
-				context.Logger.InfoFormat("Running on {0}, {1}, {2} bits",
+				context.Logger.LogInformation("Running on {0}, {1}, {2} bits",
 										  Environment.OSVersion,
 										  mono == null ?
 											  ".NET Framework v" + Environment.Version :
@@ -543,27 +544,27 @@ static void PrintEnvironmentInfo(ConfuserContext context) {
 			if (context.PackerInitiated)
 				return;
 
-			context.Logger.Error("---BEGIN DEBUG INFO---");
+			context.Logger.LogError("---BEGIN DEBUG INFO---");
 
-			context.Logger.Error("Installed Framework Versions:");
+			context.Logger.LogError("Installed Framework Versions:");
 			foreach (string ver in GetFrameworkVersions()) {
-				context.Logger.ErrorFormat("    {0}", ver.Trim());
+				context.Logger.LogError("    {0}", ver.Trim());
 			}
-			context.Logger.Error("");
+			context.Logger.LogError("");
 
 			if (context.Resolver != null) {
-				context.Logger.Error("Cached assemblies:");
+				context.Logger.LogError("Cached assemblies:");
 				foreach (AssemblyDef asm in context.InternalResolver.GetCachedAssemblies()) {
 					if (string.IsNullOrEmpty(asm.ManifestModule.Location))
-						context.Logger.ErrorFormat("    {0}", asm.FullName);
+						context.Logger.LogError("    {0}", asm.FullName);
 					else
-						context.Logger.ErrorFormat("    {0} ({1})", asm.FullName, asm.ManifestModule.Location);
+						context.Logger.LogError("    {0} ({1})", asm.FullName, asm.ManifestModule.Location);
 					foreach (var reference in asm.Modules.OfType<ModuleDefMD>().SelectMany(m => m.GetAssemblyRefs()))
-						context.Logger.ErrorFormat("        {0}", reference.FullName);
+						context.Logger.LogError("        {0}", reference.FullName);
 				}
 			}
 
-			context.Logger.Error("---END DEBUG INFO---");
+			context.Logger.LogError("---END DEBUG INFO---");
 		}
 	}
 }

Confuser.Core/ConfuserParameters.cs

@@ -1,5 +1,6 @@
 using System;
 using Confuser.Core.Project;
+using Microsoft.Extensions.Logging;
 
 namespace Confuser.Core {
 	/// <summary>
@@ -16,7 +17,7 @@ public class ConfuserParameters {
 		///     Gets or sets the logger that used to log the protection process.
 		/// </summary>
 		/// <value>The logger, or <c>null</c> if logging is not needed.</value>
-		public ILogger Logger { get; set; }
+		public Microsoft.Extensions.Logging.ILogger Logger { get; set; }
 
 		/// <summary>
 		///     Gets or sets the progress reporter used to report protection progress.
@@ -42,8 +43,8 @@ public class ConfuserParameters {
 		///     Gets the actual non-null logger.
 		/// </summary>
 		/// <returns>The logger.</returns>
-		internal ILogger GetLogger() {
-			return Logger ?? NullLogger.Instance;
+		internal Microsoft.Extensions.Logging.ILogger GetLogger() {
+			return Logger ?? Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance;
 		}
 
 		/// <summary>