获取属性名称而不通过反射传递它？

Question

I'm trying to do something like this:

    public static class Validate
    {
        public static void AgainstNull(string str)
        {
            if (String.IsNullOrWhiteSpace(str))
            {
                // how do I know the property name in the calling code?
                throw new ArgumentNullException("property name from caller");
            }
        }
    }

So that I can use a pattern similar to this in my code base:

    public void Foo(string bar)
    {
        Validate.AgainstNull(bar);

        // other processing here
    }

How do I know the name of the property which was passed in from the calling code inside of my validate method?

Answer 1

As Chris Sinclair mentioned, you can use LINQ expression, here is an example of such code:

public static class Validate
{
    public static void AgainstNull(System.Linq.Expressions.Expression<Func<string>> expr)
    {
        var str = expr.Compile().Invoke();
        if (str == null)
        {
            string name = (expr.Body as System.Linq.Expressions.MemberExpression).Member.Name;
            throw new ArgumentNullException(name);
        }
    }
}

Answer 2

It's not directly possible, but there's a technique/hack that allows the retrieval of the parameter names by making them members of an anonymous type.

Based on your example, this is not a fit. It introduces unnecessary ambiguity and requires weakly typed method signature(s). It's also measurably slower than just passing the string name of the parameter in question.

Again, don't use this for the stated purpose.

Code

void Main()
{
    Foo( "hello", "world", 123, false );
}

private static void Foo( string bar, string baz, int abc, bool xyz )
{
    Evaluate( new { bar, baz, abc, xyz } );
}

private static void Evaluate( object o )
{
    var properties = System.ComponentModel.TypeDescriptor.GetProperties( o );
    foreach( System.ComponentModel.PropertyDescriptor propertyDescriptor in properties )
    {
        var value = propertyDescriptor.GetValue( o );
        Console.WriteLine( "Name: {0}, Value: {1}", propertyDescriptor.Name, value );
    }
}

Output

Name: bar, Value: hello
Name: baz, Value: world
Name: abc, Value: 123
Name: xyz, Value: False

When might this pattern be appropriate?

It's worth noting that the ASP.Net MVC framework uses anonymous types extensively as a syntactic shortcut. The ComponentModel code comes straight from RouteValueDictionary .

Answer 3

Simple answer: you can't.

There are attributes in newer version of .NET that I thought would be helpful, but those don't look like they'd do the trick either.

Answer 4

You can use Expression Tree to get names of parameters

    public static class Validate
    {
        public static void AgainstNull(string str)
        {
            if (String.IsNullOrWhiteSpace(str))
            {
                var parametersNames = GetParameterNames(() => AgainstNull(str));
                throw new ArgumentNullException(parametersNames[0]);
            }
        }

        private static string[] GetParameterNames(Expression<Action> expression)
        {
            var methodInfo = ((MethodCallExpression)expression.Body).Method;
            var names = methodInfo.GetParameters().Select(p => p.Name);
            return names.ToArray();
        }
    }

    [Fact]
    public void AgainstNullTest()
    {
        var ex = Assert.Throws<ArgumentNullException>(() => Validate.AgainstNull(string.Empty));

        Assert.True(ex.Message.EndsWith("str"));
    }