var x = Method1().Method2().Method3().Method4();

var x1 = Method1();
if(x1 == null) return null;
var x2 = x1.Method2();
if(x2 == null) return null;
var x3 = x2.Method3();
if(x3 == null) return null;
return x3.Method4();

void Method(Option<T> opt)
{
 //неважно
}

Method(null)

public struct Option<T> : IEquatable<Option<T>>
{
    public Option(T value)
    {
        Contract.Requires(value != null);
        this.value = value;
        this.hasValue = true;
    }

    public T Value
    {
        get
        {
            if (this.hasValue)
            {
                return this.value;
            }
            else
            {
                throw new InvalidOperationException("Value is empty");
            }
        }
    }

    public bool HasValue
    {
        get { return this.hasValue; }
    }

    public bool Equals(Option<T> other)
    {
        return (this.hasValue == other.hasValue)
            && (!this.hasValue || EqualityComparer<T>.Default.Equals(this.value, other.value));
    }

    public override bool Equals(object obj)
    {
        if (obj == null || obj.GetType() != this.GetType())
        {
            return false;
        }

        var opt = (Option<T>)obj;

        return Equals(opt);
    }

    public override int GetHashCode()
    {
        return hasValue ? EqualityComparer<T>.Default.GetHashCode(value) : 0;
    }

    T value;
    bool hasValue;


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

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

    [ContractInvariantMethod]
    void ObjectInvariant()
    {
        Contract.Invariant(!hasValue || value != null);
    }
}

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

    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)
    {
        Contract.Requires(selector != null);
        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)
    {
        Contract.Requires(selector != null);
        Contract.Requires(resultSelector != null);
        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)
    {
        Contract.Requires(selector != null);
        return value.SelectMany(v => selector(v).ToOption());
    }

    public static Option<T> Where<T>(this Option<T> value, Func<T, bool> predicate)
    {
        Contract.Requires(predicate != null);
        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)
    {
        Contract.Requires(success != null);
        Contract.Requires(fail != null);
        return value.HasValue ? success(value.Value) : fail();
    }
}

var result = optionalValue.Process<IA>(value => new B(), () => new C()); //если метод интерфейса
var result = optionalValue.Process<SomeClass, IA>(value => new B(), () => new C()); //если extension метод

interface IA {}
class B: IA { }
class C: IA { }

class WebServiceOptionalValue: IOptionalValue<DateTime>
{
    public TResult Process<TResult>(Func<DateTime, TResult> existFunc, Func<TResult> notExistFunc)
    {
        DateTime webServiceMethod;
        try
        {
            webServiceMethod = WebServiceMethod();
        }
        catch
        {
            return notExistFunc();
        }
        return existFunc(webServiceMethod);
    }
}

public interface IOptionalValue<TValue>
{
    TValue Value { get; }
    bool HasValue { get; }
}

AP>class WebServiceOptionalValue: IOptionalValue<DateTime>
AP>{
AP>    public TResult Process<TResult>(Func<DateTime, TResult> existFunc, Func<TResult> notExistFunc)
AP>    {
AP>        DateTime webServiceMethod;
AP>        try
AP>        {
AP>            webServiceMethod = WebServiceMethod();
AP>        }
AP>        catch
AP>        {
AP>            return notExistFunc();
AP>        }
AP>        return existFunc(webServiceMethod);
AP>    }
AP>}
AP>

AP>А попробуйте написать реализацию интерфейса с двумя методами :

public static Option<TResult> SafeWebServiceMethod(this WebService webService, ...)
{
    try
    {
        return  webService.WebServiceMethod(...);
    }
    catch
    {
        return Option.None<TResult>;
    }
}

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

"[Одним из] недостатков является то, что паттерн 'Null Object' ... приводит к взрывному росту числа классов. Потому что необходимо создать свой 'пустой' класс для каждого абстрактного класса."

"Поедающий" сообщения nil