c# - installed - nombre de expresión en.net framework 4

net framework compatibility

Question

La expresión "nameof" se introduce en Visual Studio 2015 y c # 6

nameof (C # y referencia de Visual Basic)

¿Cómo puedes usarlo o escribir un método similar en versiones anteriores como .net framework 4?

Answer 1

El operador nameof devuelve una representación de cadena de la variable que la ha pasado, por lo que nameof (var1) devolverá "var1", es útil para evitar el código donde tenemos que especificar específicamente nombres de variables como cadenas como en excepciones de argumentos.

En versiones anteriores, se podría lograr un efecto similar utilizando la reflexión o los árboles de expresión.

Answer 2

Que yo sepa, hay tres opciones para no tener que usar una cadena mágica

1. nameof que requiere Visual Studio 2015 (pero puede compilarse para otras versiones del marco .net)

   nameof(this.Property)

2. use un método que toma una expresión y devuelve el nombre de la propiedad tal como se encuentra en esta publicación " Obtener el nombre de la cadena de la propiedad mediante la reflexión "

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

3. CallerMemberNameAttribute - (Solo disponible en .net framework 4.5, incluido porque la versión original dijo que las versiones anteriores como .net framework 4.0, que supongo que incluye 4.5) La desventaja de este método es que solo es útil cuando se necesita una representación de cadena del método actual usted está operando en.

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

Answer 3

Si está hablando de un equivalente para C # antes de C # 6, esto hará el trabajo (de una manera pirateada) para las propiedades. Probablemente se puede ampliar para incluir campos, métodos, 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;
}
}

Simplemente lo aumenté rápidamente, así que hay mucho que mejorar, pero lo usas así:

public class myClass
{
public string myProp { get; set; }
}
var a = new myClass();
var result = a.nameof(b => b.myProp);

El resultado contiene ''myProp''

Actualizar:

Más completo (aunque todavía no es tan bonito)

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;
}
}

Accediendo a propiedades / campos estáticos:

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

Accediendo a los parámetros dentro de las funciones:

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

Answer 4

nameOf : se resuelve en tiempo de Compiletime : si se descompila, verá que el compilador acaba de traducir el nombre de clase (sin el espacio de nombres (!)) en una cadena constante. Así que ten cuidado!

Si desea obtener el nombre de un classe, use typeof() o GetType() para obtener el tipo específico (quizás derivado) en Runtime y lea el valor de
La .Name .Name en .net <C # 6.

Lea más en MSDN