Add Item 12: Prefer Member Initializers to Assignment Statements

Directory.Packages.props

@@ -16,11 +16,11 @@
       - https://github.com/dotnet/roslyn/blob/main/docs/wiki/NuGet-packages.md
       - https://learn.microsoft.com/en-us/visualstudio/productinfo/vs-servicing
     -->
-
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.3.1" />
   </ItemGroup>
   <ItemGroup>
     <PackageVersion Include="BenchmarkDotNet" Version="0.13.12" />
+    <PackageVersion Include="BenchmarkDotNet.Diagnostics.dotTrace" Version="0.13.12" />
     <PackageVersion Include="GetPackFromProject" Version="1.0.6" />
     <PackageVersion Include="Nerdbank.GitVersioning" Version="3.6.139" />
     <PackageVersion Include="System.CommandLine" Version="2.0.0-beta1.21216.1" />

docs/rules/ECS1200.md

@@ -0,0 +1,89 @@
+# ECS1200: Prefer member initializers to assignment statements
+
+This rule is described in detail in [Effective C#: 50 Specific Ways to Improve your C#](https://www.oreilly.com/library/view/effective-c-50/9780134579290/).
+
+## Cause
+
+The rule identifies fields in a type that are being initialized both at the point of declaration and again within a constructor. This can lead to redundancy and potential confusion, as the field is unnecessarily re-initialized, which could also introduce bugs if the constructor logic changes.
+
+## Rule description
+
+Fields should be initialized at the point of declaration rather than within constructors when the value being assigned does not depend on any constructor parameters or instance members. This ensures consistency, reduces redundancy, and avoids potential issues with fields being out of sync.
+
+The rule will trigger when it detects that a field is initialized both at the declaration and again within a constructor with the same or a redundant value. It encourages developers to consolidate this initialization into a single place—__the field declaration__—whenever possible.
+
+## How to fix violations
+
+To fix violations, remove the redundant initialization from the constructor if the field is already initialized at the point of declaration with the same value. If the initialization must depend on constructor logic, ensure that it's not duplicated unnecessarily.
+
+## When to suppress warnings
+
+It is always safe to suppress the warning, as it highlights potentially unnecessary code and work that may be avoided.
+
+### Suppress a warning
+
+If the initialization in the constructor is necessary due to specific requirements or conditions, you might want to suppress the warning.
+
+#pragma warning disable ECS1200
+// The code that's violating the rule
+#pragma warning restore ECS1200
+
+To disable the rule for a file, folder, or project, set its severity to none in the [configuration file](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/configuration-files).
+
+```ini
+[*.cs]
+dotnet_diagnostic.ECS1200.severity = none
+```
+
+## Example of a violation
+
+### Description
+
+The following example shows a violation where a field `listOfString` is initialized both at its declaration and within the default constructor.
+
+### Code
+
+```csharp
+public class MyClass
+{
+    private List<string> listOfString = new List<string>();
+
+    public MyClass()
+    {
+        listOfString = new List<string>();
+    }
+
+    public MyClass(int size)
+    {
+        listOfString = new List<string>(size);
+    }
+}
+```
+
+## Example of how to fix
+
+### Description
+
+To fix the violation, remove the redundant initialization from the default constructor, as the field `listOfString` is already initialized with the same value at the point of declaration.
+
+### Code
+
+```csharp
+public class MyClass
+{
+    private List<string> listOfString = new List<string>();
+
+    public MyClass()
+    {
+    }
+
+    public MyClass(int size)
+    {
+        listOfString = new List<string>(size);
+    }
+}
+```
+
+## Related Rules
+
+[CA1805: Do not initialize unnecessarily](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca1805)

global.json

@@ -6,4 +6,4 @@
   "msbuild-sdks": {
     "DotNet.ReproducibleBuilds.Isolated": "1.2.4"
   }
-}
+}

src/EffectiveCSharp.Analyzers/AnalyzerReleases.Unshipped.md

@@ -1,2 +1,8 @@
 ; Unshipped analyzer release
 ; https://github.com/dotnet/roslyn-analyzers/blob/main/src/Microsoft.CodeAnalysis.Analyzers/ReleaseTrackingAnalyzers.Help.md
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+ECS1200 | Maintainability | Info | PreferMemberInitializerAnalyzer, [Documentation](https://github.com/rjmurillo/EffectiveCSharp.Analyzers/blob/97c51a41b53d059cfcd06f0c8ce5ab178b070e6b/docs/rules/ECS1200.md)

src/EffectiveCSharp.Analyzers/Build/Config/General.globalconfig

@@ -33,3 +33,10 @@ csharp_style_prefer_pattern_matching = true:warning
 #
 # Effective C# Item #10 - Use the new modifier only to react to base class Updates
 dotnet_diagnostic.CA1061.severity = warning
+
+# Title:   : Do not initialize unnecessarily
+# Category : Performance
+# Help Link: https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca1805
+#
+# Effective C# Item #12 - Prefer member initializers to assignment statements
+dotnet_diagnostic.CA1805.severity = warning

src/EffectiveCSharp.Analyzers/Common/DiagnosticExtensions.cs

@@ -1,42 +1,11 @@
-namespace EffectiveCSharp.Analyzers.Common;
+using System.Runtime.CompilerServices;
+
+namespace EffectiveCSharp.Analyzers.Common;
 
 internal static class DiagnosticExtensions
 {
     [DebuggerStepThrough]
-    internal static Diagnostic CreateDiagnostic(
-        this SyntaxNode node,
-        DiagnosticDescriptor rule,
-        params object?[]? messageArgs)
-        => node.CreateDiagnostic(rule, properties: null, messageArgs);
-
-    [DebuggerStepThrough]
-    internal static Diagnostic CreateDiagnostic(
-        this SyntaxNode node,
-        DiagnosticDescriptor rule,
-        ImmutableDictionary<string, string?>? properties,
-        params object?[]? messageArgs)
-        => node.CreateDiagnostic(
-            rule,
-            additionalLocations: null,
-            properties,
-            messageArgs);
-
-    [DebuggerStepThrough]
-    internal static Diagnostic CreateDiagnostic(
-        this SyntaxNode node,
-        DiagnosticDescriptor rule,
-        IEnumerable<Location>? additionalLocations,
-        ImmutableDictionary<string, string?>? properties,
-        params object?[]? messageArgs)
-        => node
-            .GetLocation()
-            .CreateDiagnostic(
-                rule: rule,
-                additionalLocations: additionalLocations,
-                properties: properties,
-                messageArgs: messageArgs);
-
-    [DebuggerStepThrough]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static Diagnostic CreateDiagnostic(
         this Location location,
         DiagnosticDescriptor rule,
@@ -47,6 +16,8 @@ internal static Diagnostic CreateDiagnostic(
                 properties: null,
                 messageArgs: messageArgs);
 
+    [DebuggerStepThrough]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static Diagnostic CreateDiagnostic(
         this Location location,
         DiagnosticDescriptor rule,
@@ -59,6 +30,7 @@ internal static Diagnostic CreateDiagnostic(
             messageArgs: messageArgs);
 
     [DebuggerStepThrough]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static Diagnostic CreateDiagnostic(
         this Location location,
         DiagnosticDescriptor rule,

src/EffectiveCSharp.Analyzers/Common/DiagnosticIds.cs

@@ -15,4 +15,5 @@ internal static class DiagnosticIds
     internal const string MinimizeBoxingUnboxing = "ECS0900";
     internal const string BeAwareOfValueTypeCopyInReferenceTypes = "ECS0901";
     internal const string UseSpanInstead = "ECS1000";
+    internal const string PreferDeclarationInitializersToAssignmentStatement = "ECS1200";
 }