Code inspection: Possibly unintended modification inside conditional invocation

This inspection detects cases where method calls inside conditional statements (e.g., Debug.Assert()) may lead to unintended side effects or decreased code clarity.

When a method alters the state of an object and its return value is used within a conditional statement, the logic can become obscure to readers. This reduces maintainability and increases the likelihood of unintentional errors.

Consider the following example:

        
using System.Collections.Generic;
using System.Diagnostics;

class Program
{
    void Example()
    {
        var set = new HashSet<int>();
        Debug.Assert(set.Add(1)); // Inspection warning here
        _ = set.Count;
    }
}
        
    

In this example:

The HashSet.Add method modifies the collection by attempting to add a value, and its return value (bool) indicates whether the operation succeeded.
Using this return value directly in a Debug.Assert call may confuse readers, as the intent of the assertion is unclear without understanding the details of HashSet.Add.
Modifying a collection within a conditional statement is generally non-standard practice, as it may lead to unintended side effects or misinterpretations of the intended logic.

To address this inspection and improve code clarity, consider the following approaches:

Refactor for clarity: Extract the method call's result into a well-named variable to make its purpose explicit:
bool wasAdded = set.Add(1); Debug.Assert(wasAdded);
Review intent and necessity: If the assertion or modification of the collection is unnecessary or misleading, consider refactoring or removing it to simplify the code.

By following these recommendations, you can improve code readability, reduce ambiguity, and ensure that the intent of the conditional statement is clear to anyone maintaining the code.

Last modified: 25 March 2025