A possibly-terrible alternative to conditionals full of null checks

Question

I am always super annoyed when I have to write a bunch of if statements whenever I have to traverse an object graph of possibly null objects. As there is not yet a ?. operator I resorted to creating this wonderful piece of work: TryGetProperty. Please tear it apart. This was written for LINQPad.

public bool TryGetProperty<TInstance, TFinal>(TInstance instance, Expression<Func<TInstance, TFinal>> propertyAccessor, out TFinal output)
{

    var currentExpression = propertyAccessor.Body as MemberExpression;
    var stack = new Stack<PropertyInfo>();
    do
    {
       stack.Push(currentExpression.Member as PropertyInfo);
    } while((currentExpression = currentExpression.Expression as MemberExpression) != null);

    var failed = false;

    object currentObject = instance;
    while(!failed && stack.Count > 0 )
    {
        currentObject = stack.Pop().GetMethod.Invoke(currentObject, null);
        failed = currentObject == null && stack.Count != 0;
    }

    output = failed ? default(TFinal) : (TFinal) currentObject;
    return !failed;
}

---

Example call from the same file.

void Main()
{  
    List<Class1> instances = new List<Class1> 
    {
        new Class1(),
        new Class1
        {
            Class2 = new Class2
            {
                Class3 = new Class3
                {
                    AProperty = "not null"
                }
            }
        },
        new Class1
        {
            Class2 = new Class2
            {
                Class3 = new Class3()
            }
        }
    };

    string propertyToGet;

    foreach(var instance in instances) 
    {
       if(TryGetProperty(instance, c => c.Class2.Class3.AProperty, out propertyToGet) && propertyToGet != null)
       {
            "Yay!".Dump();
       }
       else
       {
            "Boo!".Dump();
       }
    }
}

public class Class1
{
    public Class2 Class2{ get; set; }
}

public class Class2
{
    public Class3 Class3 { get; set; }
}
public class Class3
{
    public string AProperty { get; set; }
}

Answer 1

public bool TryGetProperty<TInstance, TFinal>(TInstance instance, Expression<Func<TInstance, TFinal>> propertyAccessor, out TFinal output)
{

    var currentExpression = propertyAccessor.Body as MemberExpression;
    var stack = new Stack<PropertyInfo>();
    do
    {
       stack.Push(currentExpression.Member as PropertyInfo);
    } while((currentExpression = currentExpression.Expression as MemberExpression) != null);

    var failed = false;

    object currentObject = instance;
    while(!failed && stack.Count > 0 )
    {
        currentObject = stack.Pop().GetMethod.Invoke(currentObject, null);
        failed = currentObject == null && stack.Count != 0;
    }

    output = failed ? default(TFinal) : (TFinal) currentObject;
    return !failed;
}  

This will throw an ArgumentNullException at var currentExpression = propertyAccessor.Body as MemberExpression; if propertyAccessor is null.

It will also throw the same exception if propertyAccessor.Body != MemberExpression because you are accessing the Member property here stack.Push(currentExpression.Member as PropertyInfo);.

If you use the as soft cast, you should always check the result against null.

Answer 2

I tend to use monads in such situations:

public static TResult With<TSource, TResult>(this TSource source, Func<TSource, TResult> action)
    where TSource : class
{
    if (source == null) return default(TResult);
    return action(source);
}

public static TSource Do<TSource>(this TSource source, Action<TSource> action)
    where TSource : class
{
    if (source != null)
    {
        action(source);
    }
    return source;
}

And then:

c.With(x => x.Class2).With(x => x.Class3).With(x => x.AProperty).Do(x => "Yay!".Dump());