How to get C# property names without magic strings - static reflection

A problem I’ve encountered a number of times when writing tests for C# code is that I need the name of a property or method so that I can invoke it through reflection in the tester. It is easy to get a property name through reflection:

public class Sample
{
	public static int Foo { get; set; }
}

[TestFixture]
public class When_asked_to_get_the_name_of_a_Property
{
	[Test]
	public void Should_be_able_to_get_the_name_using_reflection()
	{
		string name = typeof(Sample).GetProperty("Foo").Name;
		Assert.AreEqual("Foo", name);
	}

The problem is that if you rename the property you won’t discover that the code is now broken (due to the property name in the string being passed to GetProperty) until you run it. This makes for brittle tests. Another place one might want to avoid magic strings is in numerous places where the framework wants to take the name of a property to which to bind in order to fill a DataGrid, DropDownList, ArgumentException, etc:

private void BindData()
 {
 ddlState.DataSource = stateList;
 ddlState.DataTextValue = "Name";
 ddlState.DataFieldValue = "Code";
 ddlState.DataBind();
 }

As I haven’t seen a solution for this particular problem anywhere else I’m posting mine here. I use a feature of C# 3.5 and Linq to get the property name dynamically. First create an anonymous delegate to the property and save that as an Expression. Then drill into that expression to get the property name:

	[Test]
	public void Should_be_able_to_get_the_name_using_an_Expression()
	{
		Expression<Func<int>> expression = () => Sample.Foo;
		MemberExpression body = (MemberExpression)expression.Body;
		string name = body.Member.Name;
		Assert.AreEqual("Foo", name);
	}

Next refactor out a reusable method:

[Test]
	public void Should_be_able_to_get_the_name_using_an_Expression()
	{
		string name = ReflectionUtility.GetPropertyName(() => Sample.Foo);
		Assert.AreEqual("Foo", name);
	}
}

public static class ReflectionUtility
{
	public static string GetPropertyName<T>(Expression<Func<T>> expression)
	{
		MemberExpression body = (MemberExpression) expression.Body;
		return body.Member.Name;
	}
}

This solution suffers somewhat from being obscure in intent due to the lambda, a drawback I try to alleviate with a good method name. So far so good but the code gets a bit uglier when you start working with instance properties instead of static ones because you have to have an instance before you can wrap a lambda around the instance property:

public class Sample2
{
	public int Foo { get; set; }
}

	[Test]
	public void Should_be_able_to_get_the_name_using_an_Expression()
	{
		const Sample2 sample = null;
		string name = ReflectionUtility.GetPropertyName(() => sample.Foo);
		Assert.AreEqual("Foo", name);
	}

If there is no instance handy, however, this clutters the code so how about just using the default:

	[Test]
	public void Should_be_able_to_get_the_name_using_an_Expression()
	{
		string name = ReflectionUtility.GetPropertyName(() => default(Sample2).Foo);
		Assert.AreEqual("Foo", name);
	}

Unfortunately ReSharper now warns that default(Sample2) could be null. I could add comments to make ReSharper ignore the potential null reference exception here but then we’re back to ugly code again. If another method is added to the reflection utility, however:

	public static string GetPropertyName<T, TReturn>(Expression<Func<T, TReturn>> expression)
	{
		MemberExpression body = (MemberExpression)expression.Body;
		return body.Member.Name;
	}

Resharper’s null reference exception warning can be eliminated:

	[Test]
	public void Should_be_able_to_get_the_name_using_an_Expression()
	{
		string name = ReflectionUtility.GetPropertyName((Sample2 s) => s.Foo);
		Assert.AreEqual("Foo", name);
	}

This solution still isn’t particularly obvious in intent but at least we can do it all on one line without any magic strings or objects that only exist to provide access to the instance property.

Other lines of research… How about an extension method:

public static class Extensions
{
	public static string GetPropertyName<T,TReturn>(this Expression<Func<T,TReturn>> expression)
	{
		MemberExpression body = (MemberExpression)expression.Body;
		return body.Member.Name;
	}
}

	[Test]
	public void Should_be_able_to_get_the_name_using_an_Extension()
	{
		string name = ((Expression<Func<Sample2,int>>)(s => s.Foo)).GetPropertyName();
		Assert.AreEqual("Foo", name);
	}

It works but … is really ugly. I prefer the (Sample2 s) => s.Foo implementation and it looks OK when you only have it here and there in your code but a bunch in a single place really starts to obfuscate the code. So how about encapsulating the ugly part:

public class Sample2
{
	public static class BoundPropertyNames
	{
		// Resharper can collapse the following to a single visual line if so configured
		public static string Foo
		{
			get
			{
				return ReflectionUtility.GetPropertyName((Sample2 s) => s.Foo);
			}
		}
	}

	public int Foo { get; set; }
	// more properties ...
}

	[Test]
	public void Should_be_able_to_get_the_name_using_BoundPropertyNames()
	{
		string name = Sample2.BoundPropertyNames.Foo;
		Assert.AreEqual("Foo", name);
	}

Nifty! And as a bonus the compiler can probably boil it all down to a const… since we can boil it down to a readonly string if we really want to… check this out:

public class Sample2
{
	public static class BoundPropertyNames
	{
		public static readonly string Foo = ((MemberExpression)((Expression<Func<Sample2, int>>)(s => s.Foo)).Body).Member.Name;
	}

	public int Foo { get; set; }
}

The code for doing the same for a method is quite a bit simpler because we can get the method name from a Func directly (ignoring the limitation of getting an instance already discussed above because we usually have one):

public class Sample3
{
	public int Bar()
	{
		return 1;
	}
}

[TestFixture]
public class When_asked_to_get_the_name_of_a_Method
{
	[Test]
	public void Should_be_able_to_get_the_name_using_a_Func()
	{
		Func<int> method = default(Sample3).Bar;
		string name = method.Method.Name;
		Assert.AreEqual("Bar", name);
	}
}

Please let me know if you find a better way.

Get the latest version of this method from the MvbaCore project on github.

About these ads