CI0011-NPlusOneQueryAnalyzer

.github/workflows/publish.yml

@@ -1,8 +1,9 @@
-name: Publish to NuGet
+name: Build, Tests and Publish
 
 on:
   push:
     branches: [master]
+  pull_request:
 
 jobs:
   build-and-publish:
@@ -32,5 +33,12 @@ jobs:
     - name: Pack
       run: dotnet pack Collections.Analyzer/Collections.Analyzer.csproj --configuration Release --no-build --output nupkgs
 
+    - name: NuGet login (OIDC → temp API key)
+      uses: NuGet/login@v1
+      id: login
+      with:
+        user: Backs
+
     - name: Push to NuGet
-      run: dotnet nuget push nupkgs/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json
+      if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+      run: dotnet nuget push nupkgs/*.nupkg --api-key ${{steps.login.outputs.NUGET_API_KEY}} --source https://api.nuget.org/v3/index.json --skip-duplicate

AI_CONTEXT.md

@@ -41,6 +41,7 @@ This file is intended to help AI agents quickly understand the project structure
 ### 3. Writing Tests
 - Tests should be located in the `Tests` project; the folder should match the diagnostic name.
 - Place source code for tests in `Tests/Resources/<DiagnosticName>/`.
+- **Important**: When adding test data to the `Tests/Resources` folder, do NOT add them to `Tests.csproj` because the entire folder is already included via a wildcard.
 - Use `ResourceReader.ReadFromFile()` to load the code.
 - Use `{|CIxxxx:code|}` syntax in resource files to mark expected diagnostics.
 - Verify both the presence of the diagnostic and the result of applying the fix (if applicable).

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.3.0
+- Added [CI0011](https://github.com/Backs/Collections.Analyzer/blob/master/Documentation/CI0011.md): Diagnostic to detect potential N+1 Query Problems in loops and LINQ expressions.
+- Added support for `.editorconfig` configuration for CI0011 (data access type substrings, method prefixes, bulk method substrings, and test method analysis).
+- Improved analyzer performance by implementing configuration caching.
+- Excluded static methods and bulk/batch methods from CI0011 analysis to reduce false positives.
+- General documentation updates and refactorings.
+
 ## 0.2.15
 Added [CI0010](https://github.com/Backs/Collections.Analyzer/blob/master/Documentation/CI0010.md): Diagnostic to suggest using `Dictionary` for lookups in collections inside loops or LINQ chains. This optimizes performance from O(N*M) to O(N+M).
 

Collections.Analyzer/AnalyzerReleases.Shipped.md

@@ -1,6 +1,14 @@
 ; Shipped analyzer releases
 ; https://github.com/dotnet/roslyn-analyzers/blob/main/src/Microsoft.CodeAnalysis.Analyzers/ReleaseTrackingAnalyzers.Help.md
 
+## Release 0.3.0
+
+### New Rules
+
+ Rule ID | Category    | Severity | Notes                                 
+---------|-------------|----------|---------------------------------------
+ CI0011  | Performance | Warning  | NPlusOneQueryAnalyzer                 
+
 ## Release 0.2.15
 
 ### New Rules

Collections.Analyzer/Collections.Analyzer.csproj

@@ -6,7 +6,7 @@
         <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
         <DevelopmentDependency>true</DevelopmentDependency>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-        <PackageVersion>0.2.15</PackageVersion>
+        <PackageVersion>0.3.0</PackageVersion>
         <Title>Collections.Analyzer</Title>
         <Authors>Rogatnev Sergey</Authors>
         <Description>Collections.Analyzer is a set of roslyn-based diagnostics for C#-projects that detect potential problems with operating different collections.</Description>

Collections.Analyzer/Diagnostics/AnalyzerConfigHelper.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Collections.Analyzer.Diagnostics;
+
+internal static class AnalyzerConfigHelper
+{
+    private static readonly ConditionalWeakTable<SyntaxTree, object> ConfigCache = new();
+    private static readonly char[] Separators = { ',' };
+
+    public static T GetConfig<T>(AnalyzerOptions options, SyntaxTree syntaxTree, Func<AnalyzerConfigOptions, T> factory)
+    {
+        if (ConfigCache.TryGetValue(syntaxTree, out var cached) && cached is T typedConfig)
+        {
+            return typedConfig;
+        }
+
+        var analyzerOptions = options.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree);
+        var config = factory(analyzerOptions);
+
+        ConfigCache.Remove(syntaxTree);
+        ConfigCache.Add(syntaxTree, config!);
+
+        return config;
+    }
+
+    public static string[] GetList(AnalyzerConfigOptions options, string optionName, string[] defaultValues)
+    {
+        return options.TryGetValue(optionName, out var value) && !string.IsNullOrWhiteSpace(value)
+            ? value.Split(Separators, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray()
+            : defaultValues;
+    }
+}

Collections.Analyzer/Diagnostics/CI0008/ArrayContainsToHashSetDiagnostic.cs

@@ -38,9 +38,8 @@ public override void Initialize(AnalysisContext context)
 
     private static void AnalyzeLocalDeclaration(SyntaxNodeAnalysisContext context)
     {
-        var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
-
         var minLength = GetMinArrayLength(context);
+        var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
 
         foreach (var variable in localDeclaration.Declaration.Variables)
         {
@@ -50,9 +49,8 @@ private static void AnalyzeLocalDeclaration(SyntaxNodeAnalysisContext context)
 
     private static void AnalyzeFieldDeclaration(SyntaxNodeAnalysisContext context)
     {
-        var fieldDeclaration = (FieldDeclarationSyntax)context.Node;
-
         var minLength = GetMinArrayLength(context);
+        var fieldDeclaration = (FieldDeclarationSyntax)context.Node;
 
         foreach (var variable in fieldDeclaration.Declaration.Variables)
         {
@@ -62,6 +60,7 @@ private static void AnalyzeFieldDeclaration(SyntaxNodeAnalysisContext context)
 
     private static void AnalyzePropertyDeclaration(SyntaxNodeAnalysisContext context)
     {
+        var minLength = GetMinArrayLength(context);
         var propertyDeclaration = (PropertyDeclarationSyntax)context.Node;
 
         var typeInfo = context.SemanticModel.GetTypeInfo(propertyDeclaration.Type);
@@ -77,7 +76,6 @@ private static void AnalyzePropertyDeclaration(SyntaxNodeAnalysisContext context
             return;
 
         var arraySize = CountArrayElements(arrayInitializer);
-        var minLength = GetMinArrayLength(context);
 
         if (arraySize < minLength)
             return;
@@ -245,19 +243,6 @@ argument.Parent is ArgumentListSyntax argumentList &&
         return false;
     }
 
-    private static int GetMinArrayLength(SyntaxNodeAnalysisContext context)
-    {
-        var options = context.Options.AnalyzerConfigOptionsProvider.GetOptions(context.Node.SyntaxTree);
-
-        if (options.TryGetValue(MinArrayLengthOption, out var valueString) &&
-            int.TryParse(valueString, out var value) && value >= 0)
-        {
-            return value;
-        }
-
-        return DefaultMinArrayLength;
-    }
-
     private static int CountArrayElements(InitializerExpressionSyntax initializer)
     {
         return initializer.Expressions.Count;
@@ -269,4 +254,17 @@ private class UsageAnalysis
         public bool HasUnsupportedUsage { get; set; }
         public bool ShouldWarn => HasContainsCall && !HasUnsupportedUsage;
     }
+    private static int GetMinArrayLength(SyntaxNodeAnalysisContext context)
+    {
+        return AnalyzerConfigHelper.GetConfig(context.Options, context.Node.SyntaxTree, options =>
+        {
+            if (options.TryGetValue(MinArrayLengthOption, out var valueString) &&
+                int.TryParse(valueString, out var value) && value >= 0)
+            {
+                return value;
+            }
+
+            return DefaultMinArrayLength;
+        });
+    }
 }