Author Archive for admin

Mit Hilfe des Iterator Patterns kann sequenziell auf die Elemente eines zusammengesetzten Objekts (Aggregat) zugegriffen werden, ohne die Struktur der Elemente offen zu legen. Ein Iterator erlaubt diesen Zugriff.
Es wird verwendet, wenn mehrere Iteratoren gleichzeitig ermöglicht werden sollen, wenn ein Iterator polymorph verwendet werden soll oder wenn Datenstrukturen sich ändern aber man kein Clientcode ändern möchte. Außerdem kann ein Iteratorverhalten zur Laufzeit ausgetauscht werden. Das Muster beherzigt das Single Responsibility Principle. Eine Klasse soll nur eine Verantwortlichkeit haben.

Hier ein Codeschnipsel in PHP:

<?php

class Person
{
	private $name = "";
    public function __construct($n)
    {
        $this->name = $n;
    }

    public function Name()
    {
    	return $this->name;
    }
}

class NameFilterIterator extends FilterIterator
{
    private $nameFilter;

    public function __construct(Iterator $iterator , $filter )
    {
        parent::__construct($iterator);
        $this->nameFilter = $filter;
    }

    public function accept()
    {
        $person = $this->getInnerIterator()->current();
        if( strcasecmp($person->Name(),$this->nameFilter) == 0) {
            return false;
        }
        return true;
    }
}

class ConcreteAggregateArray implements IteratorAggregate
{
    protected $_array = array();
	public function __construct()
    {
    	$this->_array[] = new Person("Hans");
    	$this->_array[] = new Person("Seppel");
        $this->_array[] = new Person("Dirk");
   	}

    public function getIterator()
    {
        return new ArrayIterator($this->_array);
    }
}

class ConcreteAggregateObjectStore implements IteratorAggregate
{
	protected $objectStore;

	public function __construct()
    {
    	$this->objectStore = new SplObjectStorage();
    	$this->objectStore->attach(new Person("Lilli"));
    	$this->objectStore->attach(new Person("Eva"));
        $this->objectStore->attach(new Person("Herta"));
    }

    public function getIterator()
    {
        return $this->objectStore;
    }
}

class ConcreteAggregateFilteredArray implements IteratorAggregate
{
    protected $_array = array();
	public function __construct()
    {
    	$this->_array[] = new Person("Albert");
    	$this->_array[] = new Person("Adelheid");
        $this->_array[] = new Person("Anton");
   	}

    public function getIterator()
    {
        return new NameFilterIterator(new ArrayIterator($this->_array), "Adelheid");
    }
}

function PrintPersons($iteratorAggregate)
{
    foreach ($iteratorAggregate->getIterator() as $info => $value )
    {
        echo $value->Name();
        echo "<br />";
    }
}

$aggregates = array(new ConcreteAggregateArray,
					new ConcreteAggregateObjectStore,
					new ConcreteAggregateFilteredArray);
foreach ($aggregates as $info => $value)
	PrintPersons($value)
?>

Die Aggregate ConcreteAggregateArray, ConcreteAggregateObjectStore und ConcreteAggregateObjectStore implementieren das IteratorAggregate-Interface und geben jeweils einen konkreten Iterator, welcher von Iterator abgeleitet ist, zurück. Dadurch kann das Aggregat polymorph verwendet werden. Das beweist die Funktion function PrintPersons($iteratorAggregate). Mittels foreach kann ungeachtet der konkreten Form über das Aggregat iteriert werden.

Die Fassade (Facade) dient dazu, ein einheitliches Interface zu einer Menge von Interfaces eines Subsystems bereit zu stellen. Dadurch wird die Komplexität aus dem Subsystem herausgenommen und die Benutzung vereinfacht. Die Interfaces des Subystems können auch weiter seperat genutzt werden. Die Fassade ist das wohl häufigste Entwurfsmuster, mindestens was die Benutzung betrifft. Wie oft habe ich mich dabei ertappt, wie ich stundenlang nach dem einfachsten Weg suche. Hier gehts ums nackte Überleben, denn complexity kills.
Dennoch einige Beispiele:

• Die MFC ist Microsofts Fassade um die komplizierte Windows-API, um die Erstellung von Windows-Anwendungen zu vereinfachen.
• In Java sind viele manuelle Schritte nötig, nur um eine Messagebox mit den Low-Level-Klassen von Swing auf den Bildschirm zu werfen. Mit der Fassade JOptionPane.showMessageDialog(...) kann man sich viele Zeilen sparen und dies ist schnell erledigt.
• Java Swing wiederum ist selbst eine Fassade, um nicht jede geometrische Figur einzeln zeichnen zu müssen.
• Eine Computersprache selbst ist eine Fassade auf die nächst niedrigere Ebene. C#-Code ruft intern C-Code auf und dieser Assembler. Der Benutzer selbst hat die abstrakteste Fassade vor sich.

Die Beispiele sind wohl unendlich. Ob es zu den wirklichen Fortschritten gehört, eine Fassade etwa um eine STL-Collection zu bauen, die die Methoden Count() und GetAt(int) anbietet, nur weil man die die letzten 20 Jahre so programmiert hat, darüber lässt sich streiten.

Das Command-Pattern dient dazu, einen Aufruf in einem Objekt zu verpacken. Aufrufer können so zur Laufzeit mit Aufrufen bestückt werden. Aufrufe können wieder verwendet und in Listen gehalten werden. Dadurch können Aufrufe zu Makros kombiniert oder nacheinander rückgängig (Undo) gemacht werden. Aufrufer werden von aufgerufenem Empfänger strikt getrennt.

Beispielcode (C#):

using System;
using System.Collections;

namespace CommandPattern
{
    public class Player
    {
        private int _xpos;
        public int XPos
        {
            get { return _xpos; }
            set
            {
                _xpos = value;
                Console.WriteLine("XPos = {0}, YPos = {1}", _xpos, _ypos);
            }
        }

        private int _ypos;
        public int YPos
        {
            get { return _ypos;  }
            set
            {
                _ypos = value;
                Console.WriteLine("XPos = {0}, YPos = {1}", _xpos, _ypos);
            }
        }
    }

    public interface ICommand
    {
        void Execute();
        void Undo();
    }

    public class CommandMoveUp : ICommand
    {
        private Player _player;
        public CommandMoveUp(Player player)
        {
            _player = player;
        }
        public void Execute()
        {
            _player.YPos += 1;
        }
        public void Undo()
        {
            _player.YPos -= 1;
        }
    }

    public class CommandMoveDown : ICommand
    {
        private Player _player;
        public CommandMoveDown(Player player)
        {
            _player = player;
        }
        public void Execute()
        {
            _player.YPos -= 1;
        }
        public void Undo()
        {
            _player.YPos += 1;
        }
    }

    public class CommandMoveLeft : ICommand
    {
        private Player _player;
        public CommandMoveLeft(Player player)
        {
            _player = player;
        }
        public void Execute()
        {
            _player.XPos -= 1;
        }
        public void Undo()
        {
            _player.XPos += 1;
        }
    }

    public class CommandMoveRight : ICommand
    {
        private Player _player;
        public CommandMoveRight(Player player)
        {
            _player = player;
        }
        public void Execute()
        {
            _player.XPos += 1;
        }
        public void Undo()
        {
            _player.XPos -= 1;
        }
    }

    public class MoveControl
    {
        public CommandMoveDown MoveDownCommand { get; set; }
        public CommandMoveUp MoveUpCommand { get; set; }
        public CommandMoveLeft MoveLeftCommand { get; set; }
        public CommandMoveRight MoveRightCommand { get; set; }

        private Stack _commandStack = new Stack();

        public void MoveUp()
        {
            MoveUpCommand.Execute();
            _commandStack.Push(MoveUpCommand);
        }
        public void MoveDown()
        {
            MoveDownCommand.Execute();
            _commandStack.Push(MoveDownCommand);
        }
        public void MoveLeft()
        {
            MoveLeftCommand.Execute();
            _commandStack.Push(MoveLeftCommand);
        }
        public void MoveRight()
        {
            MoveRightCommand.Execute();
            _commandStack.Push(MoveRightCommand);
        }
        public void Undo()
        {
            if (_commandStack.Count == 0)
                return;

            Console.WriteLine("Undo:");
            var command = (ICommand)_commandStack.Pop();
            if (command != null)
                command.Undo();
        }
    }

    class Client
    {
        static void Main(string[] args)
        {
            var receiver = new Player();
            var moveUpCommand = new CommandMoveUp(receiver);
            var moveDownCommand = new CommandMoveDown(receiver);
            var moveLeftCommand = new CommandMoveLeft(receiver);
            var moveRightCommand = new CommandMoveRight(receiver);

            KeyboardControl invoker = new KeyboardControl();
            invoker.MoveUpCommand = moveUpCommand;
            invoker.MoveDownCommand = moveDownCommand;
            invoker.MoveLeftCommand = moveLeftCommand;
            invoker.MoveRightCommand = moveRightCommand;

            while (true)
            {
                System.ConsoleKeyInfo KInfo = Console.ReadKey(true);
                switch (KInfo.Key)
                {
                    case ConsoleKey.UpArrow:
                        invoker.MoveUp();
                        break;
                    case ConsoleKey.DownArrow:
                        invoker.MoveDown();
                        break;
                    case ConsoleKey.LeftArrow:
                        invoker.MoveLeft();
                        break;
                    case ConsoleKey.RightArrow:
                        invoker.MoveRight();
                        break;

                    case ConsoleKey.Spacebar:
                        invoker.Undo();
                        break;

                }
            }
        }
    }
}

Das Bild zeigt, dass Undo verlässlich funktioniert:

Der längliche Code spiegelt eine Eigenheit des Musters nieder. Da Befehle so eingekapselt werden, dass sie nur noch über die Methoden Execute() und Undo() verfügen, gibt es entsprechend viele Befehlsklassen. Im Beispiel erzeugt Client 4 Befehle, um eine Spielfigur jeweils 1 Schritt nach oben, unten, rechts und links gehen zu lassen. Den Befehlen wird ein ebenso erzeugter Receiver (Player) verpasst. Mit diesen Befehlen wird ein Invoker (MoveControl) bestückt (parametrisiert). MoveControl merkt sich alle aufgerufenen Befehle in einem Stack, so das auf Undo-Wunsch Undo() auf den Befehlen aufgerufen werden und diese wieder vom Stack genommen werden können.
In diesem Beispiel ist die Anzahl der Befehle noch überschaubar. Man kann sich leicht komplexere Beispiele, wie einen Rechner vorstellen, der über endlose Befehle verfügen kann wie Rechne5mal5, Rechne5mal6, Rechne1plus2, … Hier kommt man nicht umhin, für jede Anfrage des Benutzers zur Laufzeit einen neuen Befehl zu erzeugen, z.B. new CalculateCommand (string operator, double operand) und dem Invoker unterzujubeln, bevor man diesen den Befehl aufrufen lässt. Nur so können Invoker und Receiver getrennt bleiben.

Die abstrakte Fabrik hatte ich ja schon. Aber was ist der Unterschied zur Fabrikmethode? Ich zitiere aus Objektorientierte Programmierung – Das umfassende Handbuch:

• Die Fabrikmethode existiert nicht an einer eigens dafür erstellten Klasse, sondern sie ist eine zusätzliche Methode in einer bereits existierenden Klassenhierarchie.
• Die erzeugenden Klassen haben in der Regel eine konkrete technische oder fachliche Aufgabenstellung. Im Rahmen dieser Aufgabenstellung benötigen sie Exemplare von Klassen, die in einer dazu korrespondierenden parallelen Hierarchie aufgebaut sind.
• Die konkreten abgeleiteten Klassen der Erzeuger nutzen nun die Fabrikmethode, um Exemplare der jeweils benötigten konkreten Produktklassen zu erstellen.

Auch abstrakte Fabriken nutzen in der Regel Fabrikmethoden, um ihre Produkte zu erzeugen. Der entscheidende Unterschied ist aber: Die Klassenhierarchie, die für die abstrakte Fabrik aufgebaut wird, hat ausschließlich den Zweck, diese Produkte zu erzeugen.

Beispiel: Die Fabrikmethode GetEnumerator() gehört dem IEnumerable Interface an und liefert einen IEnumerator. Die das IEnumerable implementierende Klassenhierarchie, zu der z.B. ArrayList, Dictionary oder List gehören, hat die Aufgabe, mit Collections umzugehen. Dazu ist ein Iterator unerlässlich. In Patternsprache bedeutet das: Eine konkrete Fabrik z.B. ArrayList gibt per GetEnumerator() einen konkreten Iterator ArrayListEnumeratorSimple zurück, welcher vom Klienten über das IEnumerator Interface benutzt wird.

Beim Observer-Pattern geht es darum 1-n Objekte von der Zustandsänderung eines Subjekts in Kenntnis zu setzen, und das in möglichst lose gekoppelter weise.

Beispiel: In einer Autorenn-Simulation gibt es eine Ampel und verschiedene Autos. Wenn die Ampel ihren Zustand ändert, also rot, organge oder grün wird, sendet sie an alle als Observer registrierten Autos ein Update(). Als Argument übergibt sie sich selbst, so dass das Auto-Objekt dann denn Zustand lesen und entsprechend darauf reagieren kann. Wenn beispielsweise die Ampel auf rot springt, das Auto fährt, und es sich in der Nähe der Ampel befindet, muss es anhalten.

Beispielcode in C#:

using System;
using System.Collections.Generic;

namespace ObserverPattern
{
	public interface Observer
	{
		void Notify (Observable observable);
	}

	public interface Observable
    {
		void Register (Observer observer);
		void Remove (Observer observer);
		void NotifyObservers();
    }

	public enum Color {Red, Orange, Green};

	public class TrafficLight : Observable
	{
		public TrafficLight(double x, double y)
		{
			X = x;
			Y = y;
		}
		public double X { get; set; }
		public double Y { get; set; }
		Color _color = Color.Green; 

		public Color Color
		{
			get { return _color; }
			set
			{
				_color = value;
				NotifyObservers();
			}
		}

		List<Observer> _observers = new List<Observer>();
		public void Register (Observer observer)
		{
			_observers.Add(observer);
		}
		public void Remove (Observer observer)
		{
			_observers.Remove(observer);
		}
		public void NotifyObservers()
		{
			foreach (Observer observer in _observers)
				observer.Notify(this);
		}
	}

	public class Car : Observer
	{
		public Car(double x, double y)
		{
			X = x;
			Y = y;
		}
		public double X { get; set; }
		public double Y { get; set; }

		public void Notify(Observable observer)
		{
			if (! (observer is TrafficLight))
				return;

			TrafficLight tlight = (TrafficLight)observer;

			double diffX = Math.Abs(X-tlight.X);
			double diffY = Math.Abs(Y-tlight.Y);

			if (tlight.Color == Color.Red)
			{
				if (diffX < 5 || diffY < 5)
					Console.WriteLine ("Time to stop!");
				else
					Console.WriteLine ("Go on!");
			}
		}
	}

	class MainClass
	{
		public static void Main (string[] args)
		{
			Car oldtimer = new Car(15,16);
			Car rocketCar = new Car(30,40);

			TrafficLight tlight = new TrafficLight(10,20);
			tlight.Register(oldtimer);
			tlight.Register(rocketCar);

			tlight.Color = Color.Red;
		}
	}
}

Die sich ändernden Aspekte des Codes, nämlich der Zustand und die Anzahl der Observer werden Im Subjekt TrafficLight gekapselt. Subjekt wie Objekte implementieren Interfaces und es werden keine Klassen abgeleitet, sondern die Interaktion zwischen Subjekt und Objekten findet per Komposition statt. Zusätzlich sind beide Klassen lose gekoppelt. Das Subjekt kennt die Objekte nicht persönlich, sondern nur deren Interface. Objekte können jegliche Gestalt annehmen, solange sie nur das Interface implementieren. Das Subjekt kann zur Laufzeit beliebige Objekte als Observer aufnehmen und entfernen.