Existe-t-il une méthode fortement typée pour faire des événements PropertyChanged en C#?

Question

Il doit être un événement assez courant pour modifier le nom d'une propriété et attendre que la fonctionnalité Renommer dans Visual Studio prenne en charge tous les changements de nom nécessaires, à l'exception du nom de propriété de l'événement PropertyChanged de INotifyPropertyChanged. Existe-t-il un meilleur moyen de le faire typer fortement de sorte que vous n'avez pas besoin de se souvenir de le renommer manuellement?

Answer 1

Modifier: nameof est arrivé dans C# 6. Yay!

---

Il n'y a pas nameof/infoof etc; c'est beaucoup discuté, mais c'est ce que c'est.

Il existe un moyen de le faire en utilisant des expressions lambda dans .NET 3.5 (et en analysant l'arbre d'expression), mais en réalité cela ne vaut pas la surcharge. Pour l'instant, je m'en tiendrai aux cordes (et aux tests unitaires si vous êtes déterminé à ne pas le casser).

---

using System; 
using System.ComponentModel; 
using System.Linq.Expressions; 
using System.Reflection; 
class Program : INotifyPropertyChanged { 
    public event PropertyChangedEventHandler PropertyChanged; 
    static void Main() { 
     var p = new Program(); 
     p.PropertyChanged += (s, a) => Console.WriteLine(a.PropertyName); 
     p.Name = "abc"; 
    } 
    protected void OnPropertyChanged<T>(Expression<Func<Program, T>> property) { 
     MemberExpression me = property.Body as MemberExpression; 
     if (me == null || me.Expression != property.Parameters[0] 
       || me.Member.MemberType != MemberTypes.Property) { 
      throw new InvalidOperationException(
       "Now tell me about the property"); 
     } 
     var handler = PropertyChanged; 
     if (handler != null) handler(this, 
      new PropertyChangedEventArgs(me.Member.Name)); 
    } 
    string name; 
    public string Name { 
     get{return name;} 
     set { 
      name = value; 
      OnPropertyChanged(p=>p.Name); 
     } 
    } 
} 

Answer 2

Pas une réponse à votre question, mais si vous faites un clic droit-> Refactor-> Renommer une propriété, il peut également renommer les chaînes correspondantes, y compris toutes les chaînes qui correspondent au nom de votre propriété.

Oui, ça peut être un peu dangereux.

Answer 3

Le PropertyChangedEventArgs ne prend qu'un seul constructeur, ce qui nécessite le nom de la propriété sous forme de chaîne. Donc, essentiellement, ne pas utiliser INotifyPropertyChanged signifie qu'à un certain niveau, que ce soit haut ou bas dans votre architecture, vous devrez travailler avec une chaîne et renommer manuellement.

Answer 4

La solution la plus simple est de regarder la trace de la pile et supprimer toute référence completly explicite à la propriété.

public String Name 
{ 
    get { return this.name; } 
    set 
    { 
     if (value != this.name) 
     { 
      this.RaisePropertyChanging(); 
      this.name = value; 
      this.RaisePropertyChanged(); 
     } 
    } 
} 
private String name = null; 

private void RaisePropertyChanged() 
{ 
    String propertyName = 
     new StackTrace().GetFrame(1).GetMethod().Name.SubString(4); 

    PropertyChangedEventHandler handler = this.PropertyChanged; 
    if (handler != null) 
    { 
     handler(new PropertyChangedEventArgs(propertyName)); 
    } 
} 

Le code dérive le nom de la propriété à travers la trace de la pile à partir de la méthode de caling - qui est la méthode de définition de propriété nommée set_<PropertyName>. Si le compilateur ne suit plus cette convention de dénomination, le code rompt.

L'autre solution consiste à dériver le nom de la propriété d'une expression lambda.

public static String GetPropertyNameFromLambdaExpression<TObject, TProperty>(
    Expression<Func<TObject, TProperty>> expression) 
{ 
    return ((MemberExpression)expression.Body).Member.Name; 
} 

Par exemple

GetPropertyNameFromLambdaExpression<String, Int32>(s => s.Length) 

retournera "Length" comme exspected. Une version de production du code exige vraiment des vérifications supplémentaires et une meilleure intégration dans le reste du code. Par exemple, il est possible d'utiliser l'inférence de type pour les arguments génériques.

MISE À JOUR

Et il y a une troisième solution - vous pouvez utiliser MethodBase.GetCurrentMethod() dans un getter de la propriété ou setter pour obtenir le nom de la méthode setter ou getter.

public String Name 
{ 
    get { return this.name; } 
    set 
    { 
     if (value != this.name) 
     { 
      String propertyName = MethodBase.GetCurentMethod().Name.SubString(4); 

      this.RaisePropertyChanging(propertyName); 
      this.name = value; 
      this.RaisePropertyChanged(propertyName); 
     } 
    } 
} 
private String name = null; 

Answer 5

En théorie, vous pouvez utiliser MethodBase.GetCurrentMethod(). Name.Substring (4) à partir du setter de propriété. Malheureusement, la recherche Google révèle que it seems to have a significant performance impact.Deux autres éléments à prendre en compte:

• JIT inlining peut avoir un impact inattendu. (stackoverflow.com/questions/616779/can-i-check-if-the-c-compiler-inlined-a-method-call)
• En théorie, l'appel IL à MethodBase.GetCurrentMethod() pourrait être trivialement remplacé par le JIT à l'exécution avec une instruction ldtoken suivie d'un appel à MethodBase.GetMethodFromHandle(), ce qui serait très rapide. Je suppose que les utilisateurs n'ont tout simplement pas exprimé le besoin de cela. (msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.ldtoken.aspx)
• Complètement mon opinion ici, mais je pense que ce serait bien d'avoir fieldof() et methodof() opérateurs en C#. Je crois que cela améliorerait grandement la fiabilité des outils d'analyse/de refactorisation du code dans les projets qui nécessitent cette capacité.

Answer 6

Vous devriez vérifier ce blog post. Il vous donne la possibilité de le faire:

string propertyName = TypeHelper.GetPropertyName<User>(u => u.LastProjectCode); 

PropertyInfo property1 = TypeHelper.GetProperty((SomeClass o) => o.InstanceProperty.Length); 

PropertyInfo property2 = TypeHelper.GetProperty(() => SomeClass.StaticProperty.Length); 

renomme dans Visual Studio/ReSharper/Refactor Pro devrait fonctionner pour vous alors.

Answer 7

C# 5 semblent avoir une solution. Avec un CallerMemberName attribute qui peut être utilisé avec les paramètres (One example on the net).

class Employee : INotifyPropertyChanged 
{ 
    private string _Name; 
    public string Name 
    { 
     get { return _Name; } 

     set 
     { 
      _Name = value; 
      RaisePropertyChanged(); 
     } 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 

    private void RaisePropertyChanged([CallerMemberName] string caller = "") 
    { 
     var temp = PropertyChanged; 

     if (temp != null) 
     { 
      temp(this, new PropertyChangedEventArgs(caller)); 
     } 
    } 
}