Some Thoughts About Null References

Guidelines

Any programming language that allows all references to be null is fundamentally broken.
Any programming language that allows some references to be null should force you to handle both possibilities when using a potentially null reference.
If references can always be null, then you should start every public method in every public class by validating every argument and throwing an exception if any argument is null.
If references can always be null, then you should never return a null reference from any public method in any public class.

// This pattern can be used to support optional values that have reasonable semantics.

// Even so, you probably shouldn't use this pattern if a more idiomatic solution is available.

public abstract class Nullable<T> {

    public static Nullable<T> FromSomething(T value) { return new Something(value); }

    public static Nullable<T> FromNothing() { return new Nothing(); }

    public abstract TResult Match<TResult>(Func<T, TResult> something, Func<TResult> nothing);

    private Nullable() { }

    private class Something : Nullable<T> { ... }

    private class Nothing : Nullable<T> { ... }