nameof expression in .net framework 4

Question

"nameof" expression is introduced in Visual Studio 2015 and c# 6

nameof (C# and Visual Basic Reference)

How can u use it or write a similar method in older versions like .net framework 4.

Melodramatic

There is a nasty way to use Expression. – Sharpeared

The .NET Framework version isn't relevant, this is a C# 6 feature. If you're using VS 2015, you can use this and target any version of the framework. – Turnaround

For anyone who is confused regarding the C#/.NET version mismatch, please refer to #28922201 - tl;dr Roslyn converts C# 6 language features that are syntactic sugar, into code compatible with older .NET versions (so for example, nameof(parameter) becomes "parameter"). Note however, that as VS2015 is the only IDE to currently support Roslyn, this won't work in VS2013 and older. – Donettedoney

The C#6 "nameof" keyword doesn't seem capable of returning a member name for any arbitrary type. For this, a custom NameOf method taking a parameter of type Expression<Func<TSource, TProperty>> still seems necessary. – Seringapatam

Answer 1

If you're talking about an equivalent for C# before C#6, this will get the job done (in a hacky way) for properties. It can probably be expanded upon to include fields, methods, etc.

public static class TestExtension
{
    public static String nameof<T, TT>(this T obj, Expression<Func<T, TT>> propertyAccessor)
    {
        if (propertyAccessor.Body.NodeType == ExpressionType.MemberAccess)
        {
            var memberExpression = propertyAccessor.Body as MemberExpression;
            if (memberExpression == null)
                return null;
            return memberExpression.Member.Name;
        }
        return null;
    }
}

Just whipped this up quickly, so there's a lot to be improved, but you use it like this:

public class myClass
{
    public string myProp { get; set; }
}

var a = new myClass();
var result = a.nameof(b => b.myProp);

Result contains 'myProp'

Update:

More comprehensive (though still not that pretty)

public static class TestExtension
{
    public static String nameof<T, TT>(this Expression<Func<T, TT>> accessor)
    {
        return nameof(accessor.Body);
    }

    public static String nameof<T>(this Expression<Func<T>> accessor)
    {
        return nameof(accessor.Body);
    }

    public static String nameof<T, TT>(this T obj, Expression<Func<T, TT>> propertyAccessor)
    {
        return nameof(propertyAccessor.Body);
    }

    private static String nameof(Expression expression)
    {
        if (expression.NodeType == ExpressionType.MemberAccess)
        {
            var memberExpression = expression as MemberExpression;
            if (memberExpression == null)
                return null;
            return memberExpression.Member.Name;
        }
        return null;
    }
}

Accessing static properties/fields:

TestExtension.nameof(() => myClass.MyOtherField)

Accessing parameters within functions:

void func (int a) {
    TestExtension.nameof(() => a);
}

Lyricism

Answer 2

nameOf - Gets resolved at Compiletime - if you decompile, you will see that the compiler just translated the classname (without the Namespace(!)) into a constant string instead. So be aware!

If you want to get a classe's name use typeof() or GetType() to get the specific (maybe derived) type at Runtime and read the value of
the .Name-Property in .net < C#6.

Read more at MSDN

Dictionary

typeof(T).Name will return the name of the type, not the name of the variable. – Infante

I know this is old, but the point of nameof is to get a field or property name, not a type name, which was the original question asked. – Equalizer

Answer 3

To my knowledge there are three options to not have to use a magic string

1. nameof which requires Visual Studio 2015 (But can be compiled to other versions of the .net framework)

   nameof(this.Property)
   

2. use a method that takes an expression and returns the property name as found in this post "Get string name of property using reflection"

   var propertyName = GetPropertyName(  
       () => myObject.AProperty); // returns "AProperty"
   

3. CallerMemberNameAttribute - (Only available in .net framework 4.5, included because original post said older versions like .net framework 4.0 which I guess includes 4.5) The draw back of this method is it is only useful when you need to string representation of the current method you are operating in.

   public string IsChecked  {
      set{
          Console.WriteLine(GetCurrentMemberName()); // prints "IsChecked"
      }
   }
   
   string GetCurrentMemberName([CallerMemberName] string memberName = "")
   {
        return memberName;
   }
   

Enthusiast

Answer 4

The nameof operator returns a string representation of the variable you have passed it so nameof(var1) will return "var1", its useful in avoiding code where we have to specificy variable names as strings like in argument exceptions.

In previous versions you could achieve a similar effect using reflection, or expression trees.

Sacrilegious

Answer 5

@Rob, thank you so much, but the static member access could be for the non-static class members too.

public static class TestExtension {
    public static String nameof<T>(this Expression<Func<T, object>> accessor)
    {
        return nameof(accessor.Body);
    }
}
class MyClass {
    public Guid MyOtherField;
}
TestExtension.nameof<MyClass>(o=>o.MyOtherField);

and the good news is the Class won't be instantiated. It is useful to access domain layer DTOs.

Accent