System.ArgumentNullException

LINQ methods are extension methods, so calling them on a null collection does not throw a NullReferenceException. It throws an ArgumentNullException with the parameter name source.

List<Customer> customers = null;
var active = customers.Where(c => c.Id > 0).ToList();   // ArgumentNullException (Parameter 'source')

Make sure the collection exists before you query it:

List<Customer> customers = null;
var active = (customers ?? new List<Customer>()).Where(c => c.Id > 0).ToList();

A value from configuration, a query string or a form field can be null when it is not set. If it is passed straight to a method that needs a value, the exception is thrown there.

var url = configuration["ApiUrl"];   // null when the setting is missing
var uri = new Uri(url);               // ArgumentNullException (Parameter 'uriString')

Check the value where you read it, and fail with a message that says what is wrong:

var url = configuration["ApiUrl"]
    ?? throw new InvalidOperationException("ApiUrl is missing.");
var uri = new Uri(url);

If the exception comes from a guard clause in your own code, the guard is doing its job. The bug is in the caller, which is the second line of the stack trace.

public class Processor
{
    public void Process(Order order)
    {
        ArgumentNullException.ThrowIfNull(order);

        // ...
    }
}

Fix the caller, and decide what should happen when the value is missing:

var order = FindOrder(42);
if (order is null)
{
    Console.WriteLine("Order 42 does not exist.");
    return;
}

Before .NET 6, throw the exception yourself and pass the parameter name with nameof, so the name stays correct when the parameter is renamed. A throw expression keeps constructors short.

public interface IEmailSender { }

public class ReportService
{
    private readonly IEmailSender _sender;

    public ReportService(IEmailSender sender)
    {
        _sender = sender ?? throw new ArgumentNullException(nameof(sender));
    }
}

Methods that return collections should return an empty one when there is nothing to return. Callers can then pass the result on to LINQ and string.Join without checking it.

public IReadOnlyList<Customer> FindCustomers(string name)
{
    return customers.Where(c => c.Name == name).ToList();
}

With nullable reference types, the compiler warns when a value that can be null is passed to a parameter that does not accept it.

static string Join(IEnumerable<string>? names)
{
    return string.Join(", ", names);   // warning CS8604: Possible null reference argument for parameter 'values'.
}

An ArgumentNullException is thrown on purpose by a method that checks its arguments. A NullReferenceException is thrown when code uses a null reference, for example by calling a method on it. The first points at the caller, the second at a line in the method that failed.

Use ArgumentNullException.ThrowIfNull in .NET 6 and later. It picks up the parameter name from the argument expression. On older frameworks, throw new ArgumentNullException(nameof(parameter)).

Validate at the edges: public methods in libraries, and entry points of your application. Inside your own code, nullable reference types document and enforce which parameters accept null, so you do not need a guard in every method.