It is a best practice to check injected arguments for null using a helper method that supports fluent syntax. This practice helps to prevent null reference exceptions and improves the readability of the code. When a null argument is passed to a method, it can cause unexpected behavior and can be difficult to debug. By checking for null at the beginning of the method, the code can gracefully handle the situation and provide a clear error message to the user.

One way to implement this best practice is to create a static class with a method that takes an argument and throws an exception if it is null. This method can be called at the beginning of any method that takes an argument to ensure that it is not null. The method can also be designed to support fluent syntax, which makes the code more readable and easier to understand. For example:

public static class Guard
{
    public static Guard Against => new Guard();
 
    public void Null(object argument, string argumentName)
    {
        if (argument == null)
        {
            throw new ArgumentNullException(argumentName);
        }
    }
}
 
public class MyClass
{
    public void MyMethod(string argument1, object argument2)
    {
        Guard.Against.Null(argument1, nameof(argument1))
                   .Null(argument2, nameof(argument2));
 
        // Method logic here
    }
}

In the above example, the Guard class has a Null method that takes an argument and an argument name. If the argument is null, it throws an ArgumentNullException with the argument name. The MyClass class has a MyMethod that takes two arguments. The Guard.Against.Null method is called with each argument to ensure that they are not null. This makes the code more readable and easier to understand.