Add ECS0008 use the null conditional operator for event invocations (#48)

This pull request introduces a new analyzer rule, ECS0008, which is
designed to enforce the use of the null-conditional operator when
invoking event handlers in C#. This practice helps prevent potential
`NullReferenceExceptions`, improving the safety and robustness of the
code.

Key Features:
- **Detection of Potential Violations**: The rule identifies patterns
where an event handler is invoked without using the null-conditional
operator (`?.Invoke`), such as direct invocations or invocations within
an `if` statement checking for `null`.
- **Automatic Code Fixes**: The code fix provider automatically replaces
the identified pattern with the null-conditional operator, ensuring that
the event handler is only invoked when it has subscribers.
- **Comprehensive Coverage**: The rule handles cases where the event
handler is checked directly and cases where it is first assigned to a
local variable.

Example Violation:

```csharp
public class EventSource
{
    private EventHandler<int> Updated;
    private int counter;

    public void RaiseUpdates()
    {
        counter++;
        if (Updated != null)
            Updated(this, counter);
    }
}
```

Fixed code:

```csharp
public class EventSource
{
    private EventHandler<int> Updated;
    private int counter;

    public void RaiseUpdates()
    {
        counter++;
        Updated?.Invoke(this, counter);
    }
}
```

Author: rjmurillo

docs/rules/ECS0008.md

@@ -0,0 +1,81 @@
+# ECS0008: Use the Null-Conditional Operator for Event Invocations
+
+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
+
+This rule is triggered when an event handler is invoked without using the null-conditional operator (`?.`), which can potentially lead to a `NullReferenceException` if there are no subscribers to the event.
+
+
+## Rule description
+
+When invoking events in C#, it is recommended to use the null-conditional operator to ensure that the event is only invoked if it has subscribers. This prevents potential runtime errors and makes the code more robust. This rule checks for patterns where the event handler is invoked directly or after a null check and suggests replacing them with the null-conditional operator.
+
+## How to fix violations
+
+Replace any `if` statement that checks if an event handler is `null` and then invokes the handler with the null-conditional operator.
+
+If the code uses an intermediate variable (e.g., `var handler = Updated;`), remove the variable and replace the `if` statement with the null-conditional operator directly on the event.
+
+## When to suppress warnings
+
+You can suppress warnings from this rule if you're confident that the event will always have subscribers at the time of invocation, or if you have special logic that must be executed before the event is invoked.
+
+## Example of a violation
+
+### Description
+
+Directly invoking the event handler or checking for null before invoking without using the null-conditional operator.
+
+### Code
+
+```csharp
+public class EventSource
+{
+    private EventHandler<int> Updated;
+    private int counter;
+
+    public void RaiseUpdates()
+    {
+        counter++;
+        if (Updated != null)
+            Updated(this, counter);
+    }
+}
+
+public class EventSource
+{
+    private EventHandler<int> Updated;
+    private int counter;
+
+    public void RaiseUpdates()
+    {
+        counter++;
+        var handler = Updated;
+        if (handler != null)
+            handler(this, counter);
+    }
+}
+```
+
+## Example of how to fix
+
+### Description
+
+Replace the direct invocation or the null check with the null-conditional operator.
+
+### Code
+
+```csharp
+public class EventSource
+{
+    private EventHandler<int> Updated;
+    private int counter;
+
+    public void RaiseUpdates()
+    {
+        counter++;
+        Updated?.Invoke(this, counter);
+    }
+}
+```