fix: address StyleCop code quality issues

Author: jbrinkman

.editorconfig

@@ -1,16 +1,58 @@
 root = true
 
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{json,yml,yaml}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
 [*.cs]
-# Disable specific rules
-dotnet_diagnostic.SA1633.severity = none  # File header
-dotnet_diagnostic.SA1200.severity = none  # Using directive placement
-dotnet_diagnostic.SA1101.severity = none  # Prefix local calls with this
-
-# Enable all other StyleCop rules
-dotnet_analyzer_diagnostic.category-StyleCop.CSharp.DocumentationRules.severity = warning
-dotnet_analyzer_diagnostic.category-StyleCop.CSharp.LayoutRules.severity = warning
-dotnet_analyzer_diagnostic.category-StyleCop.CSharp.MaintainabilityRules.severity = warning
-dotnet_analyzer_diagnostic.category-StyleCop.CSharp.NamingRules.severity = warning
-dotnet_analyzer_diagnostic.category-StyleCop.CSharp.OrderingRules.severity = warning
-dotnet_analyzer_diagnostic.category-StyleCop.CSharp.ReadabilityRules.severity = warning
-dotnet_analyzer_diagnostic.category-StyleCop.CSharp.SpacingRules.severity = warning
+# SA1309: Field names should not begin with underscore
+dotnet_diagnostic.SA1309.severity = none
+
+# SA1413: Use trailing comma in multi-line initializers
+dotnet_diagnostic.SA1413.severity = warning
+
+# SA1000: Keywords should be spaced correctly
+dotnet_diagnostic.SA1000.severity = warning
+
+# SA1513: Closing brace should be followed by blank line
+dotnet_diagnostic.SA1513.severity = warning
+
+# SA1210: Using directives should be ordered alphabetically by namespace
+dotnet_diagnostic.SA1210.severity = warning
+
+# SA1400: Access modifier must be declared
+dotnet_diagnostic.SA1400.severity = warning
+
+# SA1201: Elements should appear in the correct order
+dotnet_diagnostic.SA1201.severity = warning
+
+# SA1202: Elements should be ordered by access
+dotnet_diagnostic.SA1202.severity = warning
+
+# SA1204: Static elements should appear before instance elements
+dotnet_diagnostic.SA1204.severity = warning
+
+# SA1128: Put constructor initializers on their own line
+dotnet_diagnostic.SA1128.severity = warning
+
+# SA1117: Parameters should be on same line or each on own line
+dotnet_diagnostic.SA1117.severity = warning
+
+# SA1503: Braces should not be omitted
+dotnet_diagnostic.SA1503.severity = warning
+
+# SA1122: Use string.Empty for empty strings
+dotnet_diagnostic.SA1122.severity = warning
+
+# SA1116: Split parameters should start on line after declaration
+dotnet_diagnostic.SA1116.severity = warning

src/DotNetApiDiff/AssemblyLoading/AssemblyLoader.cs

@@ -11,17 +11,17 @@ namespace DotNetApiDiff.AssemblyLoading;
 /// </summary>
 public class AssemblyLoader : IAssemblyLoader, IDisposable
 {
-    private readonly ILogger<AssemblyLoader> _logger;
-    private readonly Dictionary<string, Assembly> _loadedAssemblies = new();
-    private readonly Dictionary<string, IsolatedAssemblyLoadContext> _loadContexts = new();
+    private readonly ILogger<AssemblyLoader> logger;
+    private readonly Dictionary<string, Assembly> loadedAssemblies = new Dictionary<string, Assembly>();
+    private readonly Dictionary<string, IsolatedAssemblyLoadContext> loadContexts = new Dictionary<string, IsolatedAssemblyLoadContext>();
 
     /// <summary>
     /// Creates a new assembly loader with the specified logger
     /// </summary>
     /// <param name="logger">Logger for diagnostic information</param>
     public AssemblyLoader(ILogger<AssemblyLoader> logger)
     {
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
 
     /// <summary>
@@ -39,33 +39,33 @@ public Assembly LoadAssembly(string assemblyPath)
     {
         if (string.IsNullOrWhiteSpace(assemblyPath))
         {
-            _logger.LogError("Assembly path cannot be null or empty");
+            this.logger.LogError("Assembly path cannot be null or empty");
             throw new ArgumentException("Assembly path cannot be null or empty", nameof(assemblyPath));
         }
 
         // Normalize the path to ensure consistent dictionary keys
         assemblyPath = Path.GetFullPath(assemblyPath);
 
         // Check if we've already loaded this assembly
-        if (_loadedAssemblies.TryGetValue(assemblyPath, out var loadedAssembly))
+        if (this.loadedAssemblies.TryGetValue(assemblyPath, out var loadedAssembly))
         {
-            _logger.LogDebug("Returning previously loaded assembly from {Path}", assemblyPath);
+            this.logger.LogDebug("Returning previously loaded assembly from {Path}", assemblyPath);
             return loadedAssembly;
         }
 
-        _logger.LogInformation("Loading assembly from {Path}", assemblyPath);
+        this.logger.LogInformation("Loading assembly from {Path}", assemblyPath);
 
         try
         {
             // Verify the file exists
             if (!File.Exists(assemblyPath))
             {
-                _logger.LogError("Assembly file not found: {Path}", assemblyPath);
+                this.logger.LogError("Assembly file not found: {Path}", assemblyPath);
                 throw new FileNotFoundException($"Assembly file not found: {assemblyPath}", assemblyPath);
             }
 
             // Create a new isolated load context for this assembly
-            var loadContext = new IsolatedAssemblyLoadContext(assemblyPath, _logger);
+            var loadContext = new IsolatedAssemblyLoadContext(assemblyPath, this.logger);
 
             // Add the directory of the assembly as a search path
             var assemblyDirectory = Path.GetDirectoryName(assemblyPath);
@@ -78,37 +78,39 @@ public Assembly LoadAssembly(string assemblyPath)
             var assembly = loadContext.LoadFromAssemblyPath(assemblyPath);
 
             // Store the assembly and load context for later use
-            _loadedAssemblies[assemblyPath] = assembly;
-            _loadContexts[assemblyPath] = loadContext;
+            this.loadedAssemblies[assemblyPath] = assembly;
+            this.loadContexts[assemblyPath] = loadContext;
 
-            _logger.LogInformation("Successfully loaded assembly: {AssemblyName} from {Path}",
-                assembly.GetName().Name, assemblyPath);
+            this.logger.LogInformation(
+                "Successfully loaded assembly: {AssemblyName} from {Path}",
+                assembly.GetName().Name, 
+                assemblyPath);
 
             return assembly;
         }
         catch (FileNotFoundException ex)
         {
-            _logger.LogError(ex, "Assembly file not found: {Path}", assemblyPath);
+            this.logger.LogError(ex, "Assembly file not found: {Path}", assemblyPath);
             throw;
         }
         catch (BadImageFormatException ex)
         {
-            _logger.LogError(ex, "Invalid assembly format: {Path}", assemblyPath);
+            this.logger.LogError(ex, "Invalid assembly format: {Path}", assemblyPath);
             throw;
         }
         catch (SecurityException ex)
         {
-            _logger.LogError(ex, "Security exception loading assembly: {Path}", assemblyPath);
+            this.logger.LogError(ex, "Security exception loading assembly: {Path}", assemblyPath);
             throw;
         }
         catch (PathTooLongException ex)
         {
-            _logger.LogError(ex, "Path too long for assembly: {Path}", assemblyPath);
+            this.logger.LogError(ex, "Path too long for assembly: {Path}", assemblyPath);
             throw;
         }
         catch (ReflectionTypeLoadException ex)
         {
-            _logger.LogError(ex, "Failed to load types from assembly: {Path}", assemblyPath);
+            this.logger.LogError(ex, "Failed to load types from assembly: {Path}", assemblyPath);
 
             // Log the loader exceptions for more detailed diagnostics
             if (ex.LoaderExceptions != null)
@@ -117,7 +119,7 @@ public Assembly LoadAssembly(string assemblyPath)
                 {
                     if (loaderEx != null)
                     {
-                        _logger.LogError(loaderEx, "Loader exception: {Message}", loaderEx.Message);
+                        this.logger.LogError(loaderEx, "Loader exception: {Message}", loaderEx.Message);
                     }
                 }
             }
@@ -126,7 +128,7 @@ public Assembly LoadAssembly(string assemblyPath)
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Unexpected error loading assembly: {Path}", assemblyPath);
+            this.logger.LogError(ex, "Unexpected error loading assembly: {Path}", assemblyPath);
             throw;
         }
     }
@@ -140,7 +142,7 @@ public bool IsValidAssembly(string assemblyPath)
     {
         if (string.IsNullOrWhiteSpace(assemblyPath))
         {
-            _logger.LogDebug("Assembly path is null or empty");
+            this.logger.LogDebug("Assembly path is null or empty");
             return false;
         }
 
@@ -149,7 +151,7 @@ public bool IsValidAssembly(string assemblyPath)
             // Check if the file exists
             if (!File.Exists(assemblyPath))
             {
-                _logger.LogDebug("Assembly file does not exist: {Path}", assemblyPath);
+                this.logger.LogDebug("Assembly file does not exist: {Path}", assemblyPath);
                 return false;
             }
 
@@ -160,7 +162,7 @@ public bool IsValidAssembly(string assemblyPath)
                 var assembly = tempContext.LoadFromAssemblyPath(assemblyPath);
 
                 // If we got here, the assembly is valid
-                _logger.LogDebug("Successfully validated assembly: {Path}", assemblyPath);
+                this.logger.LogDebug("Successfully validated assembly: {Path}", assemblyPath);
                 return true;
             }
             finally
@@ -171,7 +173,7 @@ public bool IsValidAssembly(string assemblyPath)
         }
         catch (Exception ex)
         {
-            _logger.LogDebug(ex, "Assembly validation failed for {Path}: {Message}", assemblyPath, ex.Message);
+            this.logger.LogDebug(ex, "Assembly validation failed for {Path}: {Message}", assemblyPath, ex.Message);
             return false;
         }
     }
@@ -181,30 +183,30 @@ public bool IsValidAssembly(string assemblyPath)
     /// </summary>
     public void UnloadAll()
     {
-        _logger.LogInformation("Unloading all assemblies");
+        this.logger.LogInformation("Unloading all assemblies");
 
-        foreach (var context in _loadContexts.Values)
+        foreach (var context in this.loadContexts.Values)
         {
             try
             {
                 context.Unload();
             }
             catch (Exception ex)
             {
-                _logger.LogWarning(ex, "Error unloading assembly context");
+                this.logger.LogWarning(ex, "Error unloading assembly context");
             }
         }
 
-        _loadContexts.Clear();
-        _loadedAssemblies.Clear();
+        this.loadContexts.Clear();
+        this.loadedAssemblies.Clear();
     }
 
     /// <summary>
     /// Disposes the assembly loader and unloads all assemblies
     /// </summary>
     public void Dispose()
     {
-        _logger.LogDebug("Disposing AssemblyLoader");
+        this.logger.LogDebug("Disposing AssemblyLoader");
         UnloadAll();
         GC.SuppressFinalize(this);
     }

src/DotNetApiDiff/Models/ApiChange.cs

@@ -36,7 +36,7 @@ public class ApiChange
     /// <summary>
     /// Additional details about the change
     /// </summary>
-    public List<string> Details { get; set; } = new();
+    public List<string> Details { get; set; } = new List<string>();
 
     /// <summary>
     /// Validates the ApiChange instance
@@ -46,24 +46,34 @@ public bool IsValid()
     {
         // Must have a description
         if (string.IsNullOrWhiteSpace(Description))
+        {
             return false;
+        }
 
         // Must have at least one member for most change types
         if (Type != ChangeType.Added && Type != ChangeType.Removed &&
             SourceMember == null && TargetMember == null)
+        {
             return false;
+        }
 
         // Added changes should have target member
         if (Type == ChangeType.Added && TargetMember == null)
+        {
             return false;
+        }
 
         // Removed changes should have source member
         if (Type == ChangeType.Removed && SourceMember == null)
+        {
             return false;
+        }
 
         // Modified changes should have both members
         if (Type == ChangeType.Modified && (SourceMember == null || TargetMember == null))
+        {
             return false;
+        }
 
         return true;
     }
@@ -73,7 +83,7 @@ public bool IsValid()
     /// </summary>
     public string GetMemberName()
     {
-        return TargetMember?.FullName ?? SourceMember?.FullName ?? "Unknown";
+        return TargetMember?.FullName ?? SourceMember?.FullName ?? string.Empty;
     }
 
     /// <summary>

src/DotNetApiDiff/Models/ApiComparison.cs

@@ -8,27 +8,27 @@ public class ApiComparison
     /// <summary>
     /// List of API members that were added
     /// </summary>
-    public List<ApiChange> Additions { get; set; } = new();
+    public List<ApiChange> Additions { get; set; } = new List<ApiChange>();
 
     /// <summary>
     /// List of API members that were removed
     /// </summary>
-    public List<ApiChange> Removals { get; set; } = new();
+    public List<ApiChange> Removals { get; set; } = new List<ApiChange>();
 
     /// <summary>
     /// List of API members that were modified
     /// </summary>
-    public List<ApiChange> Modifications { get; set; } = new();
+    public List<ApiChange> Modifications { get; set; } = new List<ApiChange>();
 
     /// <summary>
     /// List of API members that were intentionally excluded
     /// </summary>
-    public List<ApiChange> Excluded { get; set; } = new();
+    public List<ApiChange> Excluded { get; set; } = new List<ApiChange>();
 
     /// <summary>
     /// Summary statistics of the comparison
     /// </summary>
-    public ComparisonSummary Summary { get; set; } = new();
+    public ComparisonSummary Summary { get; set; } = new ComparisonSummary();
 
     /// <summary>
     /// Gets all changes as a single collection
@@ -65,23 +65,33 @@ public bool IsValid()
         // Validate all changes
         var allChanges = AllChanges.ToList();
         if (allChanges.Any(c => !c.IsValid()))
+        {
             return false;
+        }
 
         // Validate that additions only contain Added changes
         if (Additions.Any(c => c.Type != ChangeType.Added))
+        {
             return false;
+        }
 
         // Validate that removals only contain Removed changes
         if (Removals.Any(c => c.Type != ChangeType.Removed))
+        {
             return false;
+        }
 
         // Validate that modifications only contain Modified changes
         if (Modifications.Any(c => c.Type != ChangeType.Modified))
+        {
             return false;
+        }
 
         // Validate that excluded only contain Excluded changes
         if (Excluded.Any(c => c.Type != ChangeType.Excluded))
+        {
             return false;
+        }
 
         return true;
     }