CODEDOM

Der Prototype ist ein Entwurfsmuster aus der Kategorie der Erzeugungsmuster (Creational Patterns), ähnlich wie der bereits beschriebene Singleton. Dabei erzeugt der Prototype neue Instanzen eines Objektes bzw. einer Klasse auf Basis einer bereits definierten Vorlage, die für neue Instanzen schlichtweg geklont werden, statt alle Felder und Eigenschaften neu zu setzen.

In den meisten Fällen kommt immer dann ein Prototype zum Einsatz, wenn das Erzeugen neuer Instanzen von Klassen sehr kostspielig ist, die Instanzen sich aber grundsätzlich sehr ähnlich sind. Es gibt hier noch eine Reihe von anderen Gründen die ich gerne zitieren möchte:

“Ein Prototyp findet Anwendung, wenn die Erzeugung weiterer Instanzen einer Klasse teuer ist und sich die Objekte ähneln, die zu instanziierenden Klassen erst zur Laufzeit bekannt sind, eine Hierarchie von Fabriken parallel zu einer Hierarchie von Produkten vermieden werden soll oder wenn die Objekte einer Klasse nur wenige Zustandskombinationen annehmen können; oder wenn die Bearbeitung von Vorlagen sehr ähnlich oder gleich der von Objekten ist.” – Quelle: wikipedia.de

Um den Prototype in Aktion sehen zu können, benötigen wir zuerst ein passendes Beispiel, welches wir uns überlegen müssen. Im Internet bin ich häufig über einen Farbenmanager gestolpert, der entweder nicht korrekt implementiert oder schlecht kommentiert wurde, daher möchte in an einem solchen Beispiel einmal die Funktionsweise des Prototypes erklären.

Als Erstes brauchen wir hier eine Klasse, welche von ICloneable abgeleitet ist, damit wir die Clone() Methoden nutzen können. Die Klasse enthält die Grundbausteine einer jeden Farbe, die RGB Werte, sowie die oben bereits genannte Methode.

class Farbe : ICloneable
{
    // Roten Anteil der Farbe holen oder setzen
    public byte R { get; set; }
 
    // Grünen Anteil der Farbe holen oder setzen
    public byte G { get; set; }
 
    // Blauen Anteil der Farbe holen oder setzen
    public byte B { get; set; }
 
    // Die Clone() Methode
    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

Das ist nun zunächst unsere Basis-Klasse, welche die grundlegenden Farbeigenschaften enthält, die wir für jede neue Farbe brauchen. Als Nächstes definieren wir uns eine ENUM, welche bestimmte Farben bereits enthält. Hier einmal die Basis-Farben rot, grün, blau sowie eigene, selbst zu definierene Farben.

enum FarbTyp
{
    Rot,
    Gruen,
    Blau,
    Eigene1,
    Eigene2,
    Eigene3
}

Um das Ganze nun einfacher und sauberer handhaben zu können, basteln wir uns noch eine FarbManager Klasse, welche mit Hilfe eines Dictionary unsere Farbtypen und unsere Farben beinhaltet.

class FarbManager
{
    private Dictionary<FarbTyp, Farbe> _farben = new Dictionary<FarbTyp, Farbe>();
 
    // Holt oder setzt die Farbe
    public Farbe this[FarbTyp typ]
    {
        get { return _farben[typ]; }
        set { _farben.Add(typ, value); }
    }
}

(Achtung, an dieser Stelle werden < als &lt; und > als &gt; dargestellt!)

Und schon steht unser Grundgerüst für den Prototype! Jetzt können wir in der Main() Methode unseren FarbManager initialisieren und unsere Farbe hinzufügen. Zum Schluss sehen wir, wie wir mit der Clone() Methode einzelne Farben kopieren können.

static void Main()
{
    var farbmanager = new FarbManager();
 
    // Standardfarben
    farbmanager[FarbTyp.Rot] = new Farbe { R = 255, G = 0, B = 0 };
    farbmanager[FarbTyp.Gruen] = new Farbe { R = 0, G = 255, B = 0 };
    farbmanager[FarbTyp.Blau] = new Farbe { R = 0, G = 0, B = 255 };
 
    // Eigene Farben
    farbmanager[FarbTyp.Eigene1] = new Farbe { R = 54, G = 90, B = 20 };
    farbmanager[FarbTyp.Eigene2] = new Farbe { R = 128, G = 128, B = 128 };
    farbmanager[FarbTyp.Eigene3] = new Farbe { R = 80, G = 120, B = 230 };
 
    // Farben aus dem FarbManager benutzen
    var farbe1 = farbmanager[FarbTyp.Rot].Clone() as Farbe;
    var farbe2 = farbmanager[FarbTyp.Eigene2].Clone() as Farbe;
}

Hier haben wir nun in den Objekten farbe1 und farbe2 die Eigenschaften R, G und B. In diesen sind die vorher durch den FarbManager festgelegten Bytes gespeichert, die unsere eigentlichen Farben darstellen. Möchte ich nun im späteren Verlauf meiner Anwendung eine Farbe benutzen, so muss ich diese nicht immer komplett neu implementieren, sondern kann über die Clone() Methode des FarbManagers mir meine Objekte jederzeit definieren. Zusätzlich hat diese Vorgehensweise den Vorteil, dass ich Farben und deren Eigenschaften, zentral an einer Stelle definieren kann ohne jederzeit im gesamten Quellcode nach neuen Farben suchen zu müssen.

Wie immer an dieser Stelle wünsche ich viel Spaß beim Testen und Tüfteln!

Quellen: Inspiration des Prototypes, dofactory