Катастрофа при Extract Method

string someMethodResult = new SomeClass1().SomeMethod1();

string someMethodResult = ExtractedMethod1().SomeMethod1();

SomeClass1 ExtractedMethod1()
{
    return new SomeClass1();
}

string someMethodResult = null.SomeMethod1(); //ошибка компиляции

string someMethodResult = ExtractedMethod1().SomeMethod1(); //ошибка в run time-е

SomeClass1 ExtractedMethod1()
{
    return null;
}

1. для передачи значений в уже имеющиеся методы (например, третий аргумент в методе PropertyInfo.SetValue),
   
2. в операторе сравнения (фактически вариант а),
   
3. может что-то забыл .

1. field-ы классов инициализируются null-ами,
   
2. оператор "as" возвращает null,
   
3. уже имеющиеся библиотеки поставляют null-ы.

string someMethodResult = OptionalValue.Nothing<SomeClass1>().Process(
    value => value.SomeMethod1(),
    () => "[Экземпляр класса SomeClass1 не существует]");

string someMethodResult = ExtractedMethod1().Process(
    value => value.SomeMethod1(),
    () => "[Экземпляр класса SomeClass1 не существует]");

IOptionalValue<SomeClass1> ExtractedMethod1()
{
    return OptionalValue.Nothing<SomeClass1>();
}

Схожесть с System.Nullable

1. OptionalValue работает и для reference и для value типов, System.Nullable только для value типов,
   
2. у OptionalValue generic параметр ковариантный.

The Maybe Monad

Query comprehension syntax

Интересные ссылки на эту тему

I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time ...
http://en.wikipedia.org/wiki/C._A._R._Hoare

A more elegant solution that will never come true is to apply value type syntax for reference types: all references are implicitly not nulls for the compiler, but a question mark after a type (ie: «string?» or «Customer?») allows you to set null to the variable.
http://codevanced.net/post/One-Annotations-Way-Resharper.aspx

1.0 Non-Null Types Many errors in modern programs manifest themselves as null-dereference errors, suggesting the importance of a programming language providing the ability to discriminate between expressions that may evaluate to null and those that are sure not to (for some experimental evidence, see [24, 22]). In fact, we would like to eradicate all null dereference errors.
http://stackoverflow.com/questions/1943465/avoiding-null-reference-exceptions

Source code of OptionalValue

    public interface IOptionalValue<out TValue>
    {
        TResult Process<TResult>(Func<TValue, TResult> existFunc, Func<TResult> notExistFunc);
    }

    public static class OptionalValue
    {
        public static IOptionalValue<TValue> Nothing<TValue>()
        {
            return NotExistOptionalValue<TValue>.Instance;
        }

        public static IOptionalValue<TValue> AsOptionalValue<TValue>(
            this TValue value)
        {
            return new ExistOptionalValue<TValue>(value);
        }

        public static IOptionalValue<TTarget> ProcessValue<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, TTarget> func)
        {
            return optionalValue.ProcessValue(value => func(value).AsOptionalValue());
        }

        public static IOptionalValue<TTarget> ProcessValue<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, IOptionalValue<TTarget>> func)
        {
            return optionalValue.Process(func, Nothing<TTarget>);
        }

        public static void Process<TValue>(
            this IOptionalValue<TValue> optionalValue, 
            Action<TValue> existAction, 
            Action notExistAction)
        {
            optionalValue.Process(existAction.ToFunc(), notExistAction.ToFunc());
        }

        public static void ProcessValue<TValue>(
            this IOptionalValue<TValue> optionalValue, 
            Action<TValue> existAction)
        {
            Process(optionalValue, existAction, () => { });
        }

        public static IOptionalValue<TTarget> Select<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, TTarget> func)
        {
            return optionalValue.ProcessValue(func);
        }

        public static IOptionalValue<TTarget> SelectMany<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, IOptionalValue<TTarget>> func)
        {
            return optionalValue.ProcessValue(func);
        }

        public static IOptionalValue<T2> SelectMany<TValue, T1, T2>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, IOptionalValue<T1>> func1,
            Func<TValue, T1, T2> func2)
        {
            return optionalValue.SelectMany(
                value => func1(value).Select(
                    value1 => func2(value, value1)
                         )
                );
        }

        public static bool HasValue<TValue>(
            this IOptionalValue<TValue> optionalValue)
        {
            return optionalValue.Process(delegate { return true; }, () => false);
        }

        public static TValue GetValue<TValue>(
            this IOptionalValue<TValue> optionalValue)
        {
            return optionalValue.Process(
                value => value,
                () =>
                    {
                        throw new InvalidOperationException(
                            string.Format("Optional value of '{0}' type has no value.", typeof (TValue)));
                    }
                );
        }

        public static TValue GetValueOrDefault<TValue>(
            this IOptionalValue<TValue> optionalValue)
        {
            return optionalValue.Process(value => value, () => default(TValue));
        }

        public static IOptionalValue<TValue> ToOptionalValue<TValue>(
            this TValue value) where TValue : class
        {
            return value == null ? Nothing<TValue>() : value.AsOptionalValue();
        }

        private class NotExistOptionalValue<TValue> : IOptionalValue<TValue>
        {
            public static readonly IOptionalValue<TValue> Instance = new NotExistOptionalValue<TValue>();

            private NotExistOptionalValue()
            {
            }

            public TResult Process<TResult>(
                Func<TValue, TResult> existFunc, Func<TResult> notExistFunc)
            {
                return notExistFunc();
            }
        }

        private class ExistOptionalValue<TValue> : IOptionalValue<TValue>
        {
            private readonly TValue value;

            public ExistOptionalValue(TValue value)
            {
                this.value = value;
            }

            public TResult Process<TResult>(
                Func<TValue, TResult> existFunc, Func<TResult> notExistFunc)
            {
                return existFunc(value);
            }
        }
    }

AP>    public interface IOptionalValue<out TValue>
AP>    {
AP>        TResult Process<TResult>(Func<TValue, TResult> existFunc, Func<TResult> notExistFunc);
AP>    }
AP>
AP>    [skipped]

public abstract class Option<T>
{
    class Just:Option<T>
    {
        T value;

        public Just(T value)
        {
            this.value = value;
        }

        public override bool HasValue
        {
            get { return true; }
        }

        public override T Value
        {
            get { return this.value; }
        }
    }

    class NoneClass:Option<T>
    {
        public override bool HasValue
        {
            get { return false; }
        }

        public override T Value
        {
            get { throw new InvalidOperationException("Value is empty"); }
        }
    }

    public abstract T Value { get; }
    public abstract bool HasValue { get; }

    private Option()
    {
    }

    public static readonly Option<T> None = new NoneClass();
    public static Option<T> Create(T value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("value");
        }
        return new Just(value);
    }

    public static implicit operator Option<T>(T value)
    {
        if (value != null)
        {
            return Create(value);
        }
        else
        { 
            return None;
        }
    }

    public static explicit operator T(Option<T> option)
    {
        return option.Value;
    }
}

public static class Option
{
    public static Option<T> None<T>()
    {
        return Option<T>.None;
    }

    public static Option<T> ToOption<T>(this T value)
    {
        return value;
    }
        
    public static Option<V> SelectMany<T,V>(this Option<T> value, Func<T, Option<V>> selector)
    {
        return value.HasValue ? selector(value.Value) : None<V>();
    }

    public static Option<V> SelectMany<T,K,V>(this Option<T> value, Func<T, Option<K>> selector, Func<T,K,V> resultSelector)
    {
        return value.SelectMany(left => selector(left).SelectMany(right => resultSelector(left, right).ToOption()));
    }

    public static Option<V> Select<T,V>(this Option<T> value, Func<T, V> selector)
    {
        return value.SelectMany(v => selector(v).ToOption());
    }

    public static Option<T> Where<T>(this Option<T> value, Func<T, bool> predicate)
    {
        return value.SelectMany(v => predicate(v) ? v.ToOption() : None<T>());
    }

    public static V Process<T,V>(this Option<T> value, Func<T, V> success, Func<V> fail)
    {
        return value.HasValue ? success(value.Value) : fail();
    }

}

class Program
{
    static void Main(string[] args)
    {
        var z1 = from c1 in 2.ToOption()
                    from c2 in 3.ToOption()
                    select c1 + c2;
        Console.WriteLine(z1.HasValue);
        Console.WriteLine(z1.Value);

        var z2 = from c1 in 2.ToOption()
                    from c2 in 3.ToOption()
                    where c2 > 3
                    select c1 + c2;
        Console.WriteLine(z2.HasValue);
    }
}

// псевдокод
static TResult Process(
     this IOptionalValue optionalValue, 
     Func<TValue, TResult> existFunc, 
     Func<TResult> notExistFunc)
{
    if(optionalValue is ExistOptionalValue)
       return existFunc(optionalValue.Value)
    else 
       return notExistFunc();
}

AP>>Скорее нет, чем да. Если пользоваться описаниями ссылка1, ссылка2, то Null Object Pattern предлагает делать кастомный интерфейс и кастомную реализацию Null Object-а для каждого случая. A OptionalValue один для всех .

A Linked list is either a head element and a tail which is a list or empty (i.e. Null). Thus is makes sense to model an abstract linked list with a class List which has two methods getTail and accept as per the Visitor pattern [GHJV95, page 331].
http://www.cs.oberlin.edu/~jwalker/nullObjPattern/

1. Нет методов Process, нет перегруженных методов ProcessValue. А это ценно.
   
2. Нет ковариантности generic параметра. Поэтому нельзя пользоваться полиморфизмом по generic параметру, что очень печально.
   
3. Метод Select по правилам должен называться SelectMany.
   
4. Нет методов SelectMany и Select для поддержки query comprehension syntax.
   
5. Метод Some должен быть extension методом.

public static void Process<TValue>(
    this IOptionalValue<TValue> optionalValue, 
    Action<TValue> existAction, 
    Action notExistAction)
{
    optionalValue.Process(
        value =>
            {
                existAction(value);
                return new {};
            },
        () =>
            {
                notExistAction();
                return new {};
            });
}

G>public abstract class Option<T>

G>>    public static V Process<T,V>(this Option<T> value, Func<T, V> success, Func<V> fail)
G>>    {
G>>        return value.HasValue ? success(value.Value) : fail();
G>>    }
G>>

1. Не хочется иметь в базовом интерфейсе свойство, кидающее исключение.
   
2. В случае если не срабатывает type inference, то для extension метода Process придется явно прописывать значения обоих generic параметров. А если Process является методом интерфейса, то прописывать придется значение только одного generic параметра.

Хочется иметь такую технику кодирования, чтобы Extract Method не переводил ошибки компиляции в ошибки run time-а.