Archive

Posts Tagged ‘Clean Code’

Compiler warning CS0067 – es muss nicht immer #pragma sein

July 29th, 2010 Bernd 2 comments

warningSignDa ist es wieder. Der Compiler spuckt die Warnung CS0067 “The event ‘XXX’ is never used” aus. Das kann z.B. passieren, wenn das Interface ICommand implementiert wird, das Command aber immer ausführbar sein soll. Das Event CanExecuteChanged muss also nie gefeuert werden:

 

 

public class SomeCommand : ICommand
{
	public void Execute(object parameter)
    {
		// do sth.
	}

	public bool CanExecute(object parameter)
    {
		return true;
	}

	public event EventHandler CanExecuteChanged;
}

Bei obiger Imlementierung bekommt man beim Übersetzten die Compiler Warnung CS0067:

warning CS0067: The event ‘CommandDemo.SomeCommand.CanExecuteChanged’ is never used

Was einem als erstes (zumindest mir) einfällt die Warning zu “beheben”, ist sie mit einem #pragma Statement kurzzeitig aus- und wieder einzuschalten:

#pragma warning disable 0067
	public event EventHandler CanExecuteChanged;
#pragma warning restore 0067

So richtig gut gefällt diese Lösung aber nicht. Bei Implementierungen, wo das Event später vielleicht doch einmal gefeuert wird, ist die Wahrscheinlichkeit ziemlich hoch, dass diese #pragma Statements vergessen werden und im Code verbleiben. Das ist nicht schön. Aber es gibt eine andere, (mittlerweile meiner Ansicht nach bessere) Lösung:

public event EventHandler CanExecuteChanged { add{} remove{} }

Durch das Hinzufügen der leeren Eventaccessors “add” und “remove” mache ich klar, dass dieser Event nicht verwendet wird. Da das Event sowieso nie gefeuert wird, ändert sich auch für den potentiellen Konsumenten des Events nichts. Wenn in einer späteren Phase dieser Event doch einmal ausgelöst werden soll, wird der Entwickler sofort mit einem Kompilerfehler darauf hingewiesen, das dies nicht möglich ist. Die leeren “add” und “remove” Accessoren müssen also entweder wieder entfernt oder entsprechend vollständig implementiert werden ==> der Code bleibt sauber.

Wie man sieht, muss man also nicht sofort zum #pragma greifen, wenn man mit der Warnung CS0067 konfrontiert wird. Das Hinzufügen der leeren Eventaccessoren bietet eine elegante und saubere Lösung mit dem Fall umzugehen.

Categories: Softwareentwicklung Tags: ,

INotifyPropertyChanged – Varianten für die Implementierung

September 2nd, 2009 Bernd 6 comments

Wer mit WPF programmiert, kennt INotifyPropertyChanged. Das allgegenwärtige Interface, mit dem Änderungen z.B. von einem ViewModel zu einem daran gebunden UI Element propagiert werden. Eine typische Implementierung von INotifyPropertyChanged sieht etwa so aus:

INotifyPropertyChanged Horror

Drei Sachen fallen ins Auge

  1. jedes ViewModel muss INotifyPropertyChanged implementieren, d.h. den PropertyChanged Event anbieten und eine Methode zum Feuern des Events haben.
  2. die EventArgs für den PropertyChanged Event bekommen als Parameter einen String, der dem Namen der Property entspricht.
  3. der Code ist “zugemüllt” mit Infrastrukturcode, der eigentlich nichts zur Logik des Objekts beiträgt
    Der erste Punkt lässt sich relativ einfach lösen, indem man eine ViewModel Basisklasse macht, die diese Aufgaben übernimmt.
    Basisklasse für ViewModels
    public abstract class ViewModelBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
    
        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }

Beim zweiten Punkt wird es dann schon schwieriger. Hier gibt es mehrere Ansätze, die Strings loszuwerden.

Am häufigsten trifft man wohl eine Variante mit Lambda Expressions an. Die Implementierungen reichen von einer Extensionmethod für den PropertyChangedEventHandler bis zu einer generischen ViewModel Basisklasse, welche das abgeleitete ViewModel als Type Parameter bekommt. Hier ein paar Links zum Nachlesen:

J.P. Hamilton – Generische ViewModel Basisklasse

Stefan Lieser – Implementierung direkt im ViewModel

Eric De Carufel – Extensionmethod für PropertyChangedEventHandler

 

Andere Lösungen, die ich gefunden habe:

Alkampfer – INotifyPropertyChanged mit CodeDom implementieren

Ayende – INotifyPropertyChanged mit Castle Dynamic Proxy

Mike Saunders – INotifyPropertyChanged mit PostSharp Aspekt

Richard Banks – INotifyPropertyChanged mit PostSharp Aspekt

 

Dann gibt es noch die den Verfechter von UpdateControls, Michael L. Perry. UpdateControls ist eine Open Source Bibliothek auf CodePlex, die es erlaubt, Änderungen von Eigenschaften auch ohne INotifyProperyChanged zu propagieren und z.B. an WPF Controls zu binden. Eine gute Einführung in UpdateControls kann man beim CODE Magazin lesen.

 

Mir gefallen bisher die Lösungen mit PostSharp am Besten. Damit lassen sich alle drei Punkte auf einmal erschlagen.

  1. Mit einem PostSharp Attribut, das auf die ViewModel Klasse geklebt wird, lässt man die INotifyPropertyChanged Implementierung automatisch einweben.
  2. Es gibt keine Magic Strings mehr, da auch das Feuern des ProperyChanged Events automatisch eingewoben wird. Verschreiber sind dadurch ausgeschlossen, Refactoring ist kein Problem.
  3. Der Code bleibt sauber und lesbar, da der ganze Notifikationscode erst nachträglich hinzugefügt wird.
    Der nächste Schritt

Ein Kollege von mir hatte die Idee, die Verwendung von PostSharp in Verbindung mit dem MVVM Pattern noch einen Schritt weiter zu treiben. Wir verwenden jetzt ein [ViewModelAspekt] PostSharp Attribut, mit dem die ViewModels versehen werden.

[ViewModelAspect]
public class MyViewModel
{
    private string _name;

    public string Name
    {
        get{ return _name;}
        set{ _name = value;}
    }

    public void Save()
    {
        // do sth.
    }
}

Dieser Aspekt macht folgendes:

  • Implementierung von INotifyPropertyChanged
  • Für alle public Properties wird im Setter der PropertyChanged Event gefeuert
  • Für alle public void Methoden wird eine Command Property erzeugt, welche mit Hilfe des Delegate/Relay Commands wiederum diese Methode aufruft.
    Dadurch haben wir es geschafft, den Overhead für die Verwendung des MVVM Patterns sehr gering zu halten. Die nächsten Wochen werden zeigen, ob sich diese Variante bewährt und alle Use Cases damit abgedeckt werden können.