.NET Junkie

It's already over a year ago that I sent this e-mail to 'ask a language designer'. I forgot all about it and never got an answer. And now a ask you, my dear readers, what do you think of this feature request?

Dear C# Language Designers,
 
The last several years, refactoring and data binding have become more and more popular. Refactoring enables us to change a function name throughout an enormous code base with almost a single click, while data binding allows us to bind to objects and discover properties and methods at runtime.
 
These two features, however, don't match. In the example below, I will point out this problem, after which I’ll describe the C# feature I’d really like to have.
 
In ASP.NET 2.0 we have a new control called ObjectDataSource. This control lets us bind to a method of a certain type, by defining the TypeName and SelectMethod. The problem here, is that these properties are strings. The effect of which is that a type name or method name can not be found by the refactoring tool, like in the following code:

class MyClass
{
     public void MyMethod() { }
     public void MyMethod(int i, double d) { }
     public void MyProperty { get; set; }
}

static void Main()
{
     ObjectDataSource ds = new ObjectDataSource();
     s.TypeName = "MyAssembly.MyClass";
     ds.SelectMethod = "MyMethod";
} 

We can rewrite the previous code snippet in such a way that the strings will disappear and the code will become actually refactorable.

class MyClass [...]

delegate void MyDelegate();
 
static void Main()
{
    ObjectDataSource ds = new ObjectDataSource();
    ds.TypeName = typeof(MyClass).FullName;
    ds.SelectMethod =
        (new MyDelegate((new MyClass()).MyMethod)).Method.Name;
}

Right away we can see the problem. For setting the TypeName, the problem was easily solved by using typeof(MyClass).FullName. Retrieving the name of the method is far more complex. Besides that, for every method for which we want to extract it’s name, we must define a delegate with the same contract as the method. Even worse, retrieving property names is impossible (without reintroducing strings of course).
 
What we need is a feature, that brings the two worlds together, so we can build more maintainable programs. A construct, much like the typeof operator, that can determine the name of a function at compile time! I can imagine the code to look like this:

ObjectDataSource ds = new ObjectDataSource();
ds.TypeName = typeof(MyClass).FullName;
ds.SelectMethod = nameof(MyClass.MyMethod(int, double));
string propertyName = nameof(MyClass.MyProperty);

As you can see I propose a special language syntax, that can only hold within the brackets of the nameof operator. To be able to uniquely identify a method (overload), the nameof operator must contain the function's argument types. Note that member and static functions are both written with the static method syntax.
 
I’d really like to hear your thoughts on this matter.
 
Best regards
 
 
Steven

Update 2008-12-03:
Eric Lippert posted a great comment (already over 3 months ago). I have been playing around with his code sample and extended it a bit, but forgotten all about it. Today a former colleague of mine asked about this code, so here is my version. Good luck with it:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

public static class Utilities
{
    public static string NameOf(Expression<Action> x)
    {
        return NameOfInternal(x.Body);
    }

    public static string NameOf<T>(Expression<Func<T, object>> x)
    {
        return NameOfInternal(x.Body);
    }

    private static string NameOfInternal(Expression expression)
    {
        if (expression is UnaryExpression)
        {
            expression = ((UnaryExpression)expression).Operand;
        }

        if (expression is MemberExpression)
        {
            return BuildMemberExpressionName(expression);
        }
        else if (expression is MethodCallExpression)
        {
            return ((MethodCallExpression)expression).Method.Name;
        }
        else if (expression is ConstantExpression)
        {
            var value = ((ConstantExpression)expression).Value;

            return value != null ? value.ToString() : null;
        }
        else
        {
            throw new InvalidOperationException(string.Format("{0} is not supported.", expression.GetType()));
        }
    }

    private static string BuildMemberExpressionName(Expression expression)
    {
        var members = new List<string>();

        var memberExpression = expression as MemberExpression;

        while (memberExpression != null)
        {
            members.Add(memberExpression.Member.Name);

            memberExpression = memberExpression.Expression as MemberExpression;
        }

        members.Reverse();

        return string.Join(".", members.ToArray());
    }
}

The code samples on my weblog are colorized using javascript, but you disabled javascript (for my website) on your browser. If you're interested in viewing the posted code snippets in color, please enable javascript.