web-dev-qa-db-fra.com

nom de l'expression dans le framework .net 4

L'expression "nameof" est introduite dans Visual Studio 2015 et c # 6

nameof (référence C # et Visual Basic)

Comment pouvez-vous l'utiliser ou écrire une méthode similaire dans les anciennes versions comme .net framework 4.

c#c#-6.0nameof
22
MSL

Si vous parlez d'un équivalent pour C # avant C # 6, cela fera le travail (d'une manière hacky) pour les propriétés. Il peut probablement être étendu pour inclure des champs, des méthodes, 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;
    }
}

Il suffit de préparer rapidement ceci, donc il y a beaucoup à améliorer, mais vous l'utilisez comme ceci:

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

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

Le résultat contient 'myProp'

Mise à jour:

Plus complet (mais toujours pas si joli)

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

Accès aux propriétés/champs statiques:

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

Accès aux paramètres dans les fonctions:

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

nameOf - Est résolu dans Compiletime - si vous décompilez, vous verrez que le compilateur vient de traduire le nom de classe (sans l'espace de noms (!)) en une chaîne constante à la place. Alors soyez conscient!

Si vous voulez obtenir le nom d'une classe, utilisez typeof() ou GetType() pour obtenir le type spécifique (peut-être dérivé) à Runtime et lisez la valeur de
les .Name- Propriété dans .net <C # 6.

En savoir plus sur MSDN

4
Cadburry

À ma connaissance, il existe trois options pour ne pas avoir à utiliser une chaîne magique

  1. nameof qui nécessite Visual Studio 2015 (mais peut être compilé vers d'autres versions du framework .net)

    nameof(this.Property)

  2. utiliser une méthode qui prend une expression et retourne le nom de la propriété tel que trouvé dans cet article " Obtenir le nom de chaîne de la propriété en utilisant la réflexion "

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

  3. CallerMemberNameAttribute - (Uniquement disponible dans .net framework 4.5, inclus parce que le message d'origine mentionnait des versions plus anciennes comme .net framework 4.0 qui, j'imagine, inclut 4.5) vous opérez.

    public string IsChecked  {
   set{
       Console.WriteLine(GetCurrentMemberName()); // prints "IsChecked"
   }
}

string GetCurrentMemberName([CallerMemberName] string memberName = "")
{
     return memberName;
}
2
JamesF

L'opérateur nameof retourne une représentation sous forme de chaîne de la variable que vous lui avez transmise afin que nameof (var1) renvoie "var1", son utile pour éviter le code où nous devons spécifiquement spécifier les noms de variable comme des chaînes comme dans les exceptions d'argument.

Dans les versions précédentes, vous pouviez obtenir un effet similaire en utilisant des arbres de réflexion ou d'expression.

1
BhavO