Why is this an issue?

An empty method is generally considered bad practice and can lead to confusion, readability, and maintenance issues. Empty methods bring no functionality and are misleading to others as they might think the method implementation fulfills a specific and identified requirement.

Such methods should be avoided and possibly removed.

void DoSomething() { } // Noncompliant

However, there are some cases where a method needs to be empty. In those cases, it is essential to minimize confusion and enhance clarity.

Here are a few examples:

The method will never be implemented. You can make clear the initial intention not to implement the method in the future by throwing the NotSupportedException.
```
void DoSomething() => // Compliant
    throw new NotSupportedException();
```
The method will be implemented in the future. You can make clear the initial intention to add an implementation in the future by throwing the NotImplementedException.
```
void DoSomething() => // Compliant
    throw new NotImplementedException();
```
The method implementation is empty intentionally. In this case, it is important to put a comment explaining the reason for the empty implementation.
```
void DoSomething() // Compliant
{
    // Do nothing because of X
}
```

Exceptions

The following empty methods are considered compliant:

empty virtual methods as the implementation might not be required in the base class
empty methods that override an abstract method as the implementation is mandatory for child class
empty overrides in test assemblies for mocking purposes