Une manière concise de définir des propriétés pour la liaison de données MVVM dans C# WPF

Question

Existe-t-il une manière concise de définir des propriétés dans un ViewModel pour la liaison de données dans C# WPF? La définition de la propriété suivante est très bavard, surtout quand il y a beaucoup de propriétés:

private bool mSomeProperty; 

public bool SomeProperty 
{ 
    get { return this.mSomeProperty; } 
    set 
    { 
     if (value != this.mSomeProperty) 
     { 
      this.mSomeProperty = value; 
      OnPropertyChanged(new PropertyChangedEventArgs("SomeProperty")); 
     } 
    } 
} 

Answer 1

en C#, je tiens à faire une classe de base et de mettre certaines méthodes d'aide à ce sujet. Ensuite, je fais en sorte que mes ViewModels en descendent. Ceci est de la mémoire, mais il est quelque chose comme ceci:

public class Observable : INotifyPropertyChanged 
{ 
    public event PropertyChangedEventHandler PropertyChanged; 

    protected void SetProperty<T>(ref T backingField, T newValue, 
     string propertyName) 
    { 
     if (Equals(backingField, newValue)) 
      return; 
     backingField = newValue; 
     if (PropertyChanged != null) 
     { 
      PropertyChanged(this, 
       new PropertyChangedEventArgs(propertyName)); 
     } 
    } 
} 

Et, dans l'usage:

public class MyClass : Observable 
{ 
    private bool m_someProperty; 

    public bool SomeProperty 
    { 
     get { return m_someProperty; } 
     set { SetProperty(ref m_someProperty, value, "SomeProperty"); } 
    } 
} 

Answer 2

Si vous utilisez le langage Delphi Prism (langage .NET base Pascal), vous ajoutez simplement le mot-clé notify, et compilateur implémente automatiquement INotifyPropertyChanged et écrit tout le code passe-partout pour vous:

property SomeProperty: bool; notify; 

Answer 3

Je pense que vous ne serez pas obtenir la déclaration de propriété beaucoup plus petite que cela, du moins pas avec des moyens « normaux ». Vous pouvez utiliser un intercepteur de château pour prendre soin de l'événement raisal.

public class MyViewModel : INotifyPropertyChanged 
{ 
    public event PropertyChanged; 
    public void FirePropertyChanged(string propertyName) 
    { 
     if (PropertyChanged != null) PropertyChanged(propertyName); 
    } 

    public virtual string MyProperty { get; set; } 
    public virtual string MyProperty2 { get; set; } 
} 

L'intercepteur devrait déclencher l'événement a changé la propriété:

public class PropertyChangedInterceptor : IInterceptor 
{ 
    public void Intercept(IInvocation invocation) 
    { 
     //Pseudo code 
     if (invocation.Method is Property Setter) 
     { 
      Call FirePropertyChanged of invocation.InvocationTarget ; 
     } 
    } 
} 

Vous devez juste vous assurer que les propriétés du modèle de votre vue sont le modèle virtuel et votre point de vue est toujours un proxy et non le point de vue modèle lui-même.

Cordialement

Answer 4

Vous pouvez toujours utiliser DependencyProperties et propdp votre coeur ...

Answer 5

Vous pouvez envisager PostSharp qui vous permettra de décorer la propriété (que vous pourriez ensuite redéfinir comme propriété auto) et d'injecter dans le setter la ligne qui déclenche l'événement NotifyPropertyChanged. Un avantage supplémentaire est que vous vous débarrasser de la chaîne qui est le même que le nom de la propriété.

Ce n'est pas idéal parce que vous avez besoin de cet outil et il ne sera pas immédiatement évident si vous regardez le code plus tard, mais il le rend nettement plus net.

J'espérais que MSFT ajouterait un tel attribut au C# 4 mais je suppose que nous devrons attendre le C# 5, voire pas du tout.

Answer 6

Vous pourriez trouver quelques idées ici:

mise en œuvre et l'utilisation de INotifyPropertyChanged https://github.com/jbe2277/waf/wiki/Implementing-and-usage-of-INotifyPropertyChanged