从该方法中获取变量调用方法的名称

Question

I want to create an extension method for objects that check to see if the object is null and throw an exception if it is. I want to keep the original variable name though. Can I somehow get it from within the extension method? It is "cumbersome" to have to write customer.NotNull("customer") vs customer.NotNull() .

Answer 1

No, unfortunately you can't. Variable names are not part available at run time. However, you can use expressions like this:

void NotNull<T>(Expression<Func<T>> expression)
{
    var me = expression.Body as MemberExpression;
    var name = me.Member.Name;
    var value = expression.Compile().Invoke();
    ...
}


NotNull(() => customer);

Answer 2

// using System.Diagnostics.Contracts;
using System.Linq.Expressions;

static void ThrowIfNull<T>(Expression<Func<T>> expr) where T : class
{
    // Contract.Requires(expr != null);
    // Contract.Requires(expr.Body.NodeType == ExpressionType.MemberAccess);
    if (((object)expr.Compile().Invoke()) == null)
    {
        throw new ArgumentNullException(((MemberExpression)expr.Body).Member.Name);
    }
}

Then call it like this:

object someVariable = null;
ThrowIfNull(() => someVariable);  // will throw an ArgumentNullException 
                                  // with paramName == "someVariable"

PS: I am not sure whether this is a good idea: There will be an overhead for first building an expression tree, and then compiling it each time this method is called, just so that you can check whether the variable contains a null reference, and if so, retrieve the variable name. Something like void ThrowIfNull<T>(T arg, string paramName) is not as nice, but is likely o perform much better!

Answer 3

As the other said, but note that compiling an expression is something slow... So this variant receives the value as a parameter. You have to write more, but for methods that are called hundred of times, it could be better.

[DebuggerHidden]
public static void NotNull<T>(T value, Expression<Func<T>> exp) where T : class
{
    if (value != null)
    {
        return;
    }

    var body = exp.Body as MemberExpression;

    if (body == null)
    {
        throw new ArgumentException("Wrongly formatted expression");
    }

    throw new ArgumentNullException(body.Member.Name);
}

Usage:

NotNull(str, () => str);

The [DebuggerHidden] is so that the debugger won't step into the method. In the end if the method throws, normally it's because what you passed, not what there is in the method.