Add ECS1400 documentation

Author: rjmurillo

Diff for: docs/rules/ECS1400.md

@@ -0,0 +1,89 @@
+# ECS1400: Minimize duplicate initialization logic
+
+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
+
+Constructors within a class contain duplicate initialization logic, leading to code duplication and potential maintenance issues.
+
+## Rule Description
+
+This rule identifies constructors in a class that perform the same or similar initialization steps independently, rather than delegating to a common constructor. Duplicate initialization logic can make the code harder to maintain and increase the risk of bugs when changes are made. By minimizing duplicate initialization logic through constructor chaining, you centralize the initialization code, making it easier to manage and update.
+
+## How to fix violations
+
+Refactor the constructors to use constructor chaining. Identify a primary constructor that contains the shared initialization logic, and have other constructors delegate to it using the `this()` syntax. This ensures that all initialization steps are centralized in one place.
+
+## When to suppress warnings
+
+You might suppress this warning if:
+
+- Constructor chaining is not feasible due to specific requirements or design constraints.
+- The initialization logic, while similar, needs to be executed separately in each constructor for correctness.
+- Performance considerations prevent the use of constructor chaining in a particular scenario.
+
+### Suppress a warning
+
+If you just want to suppress a single violation, add preprocessor directives to your source file to disable and then re-enable the rule.
+
+```csharp
+#pragma warning disable ECS1400
+// The code that's violating the rule
+#pragma warning restore ECS1400
+```
+
+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.ECS1400.severity = none
+```
+
+## Example of a violation
+
+### Description
+
+In this example, the `MyClass` class has multiple constructors that contain duplicate initialization logic. Each constructor initializes the `_value` field independently with the same value.
+
+### Code
+
+```csharp
+public class MyClass
+{
+    private int _value;
+
+    public MyClass()
+    {
+        _value = 10;
+    }
+
+    public MyClass(int value)
+    {
+        _value = value;
+    }
+}
+```
+
+## Example of how to fix
+
+### Description
+
+Refactor the constructors to use constructor chaining. Designate one constructor as the primary initializer (e.g., the one accepting parameters), and have other constructors delegate to it using the `this()` syntax.
+
+### Code
+
+```csharp
+public class MyClass
+{
+    private int _value;
+
+    public MyClass() : this(10)
+    {
+    }
+
+    public MyClass(int value)
+    {
+        _value = value;
+    }
+}
+```