## Why is this an issue?

Methods declared as `public`, `protected`, or `protected internal` can be accessed from other assemblies, which means you should validate parameters to be within the expected constraints. In general, checking against `null` is recommended in defensive programming.

This rule raises an issue when a parameter of a publicly accessible method is not validated against `null` before being dereferenced.

### Noncompliant code example

    public class MyClass
    {
        private MyOtherClass other;

        public void Foo(MyOtherClass other)
        {
            this.other = other.Clone(); // Noncompliant
        }

        protected void Bar(MyOtherClass other)
        {
            this.other = other.Clone(); // Noncompliant
        }
    }

### Compliant solution

    public class MyClass
    {
        private MyOtherClass other;

        public void Foo(MyOtherClass other)
        {
            if (other != null)
            {
                this.other = other.Clone();
            }
        }

        protected void Bar(MyOtherClass other)
        {
            if (other != null)
            {
                this.other = other.Clone();
            }
        }

        public void Baz(MyOtherClass other)
        {
            ArgumentNullException.ThrowIfNull(other);

            this.other = other.Clone();
        }

        public void Qux(MyOtherClass other)
        {
            this.other = other; // Compliant: "other" is not being dereferenced
        }

        private void Xyzzy(MyOtherClass other)
        {
            this.other = other.Clone(); // Compliant: method is not publicly accessible
        }
    }

### Exceptions

- Arguments validated for `null` via helper methods should be annotated with the `[NotNull`] attribute.
- Method parameters marked with the `[NotNull]` Resharper code annotation attribute are supported as well.
- To create a custom null validation method declare an attribute with name `ValidatedNotNullAttribute` and mark the parameter that is validated for null in your method declaration with it:

    using System;

    [AttributeUsage(AttributeTargets.Parameter, Inherited=false)]
    public sealed class ValidatedNotNullAttribute : Attribute { }

    public static class Guard
    {
        public static void NotNull<T>([ValidatedNotNullAttribute] T value, [CallerArgumentExpression("value")] string name = "") where T : class
        {
            if (value == null)
                throw new ArgumentNullException(name);
        }
    }

    public static class Utils
    {
        public static string ToUpper(string value)
        {
            Guard.NotNull(value);

            return value.ToUpper(); // Compliant
        }
    }