Viele Online‑Dienste bieten zwar „kostenfreie“ QR‑Codes® an, leiten jedoch Weblinks über ihre eigenen Server um. Nach einer gewissen Anzahl von Scans oder nach einer Testphase verlangen einige dieser Anbieter plötzlich monatliche Gebühren oder ein kostenpflichtiges Upgrade.

Um genau diese Abhängigkeiten und versteckten Kosten zu vermeiden, wurde dieses Programm entwickelt. Es ermöglicht das Erstellen von QR‑Codes® direkt auf dem eigenen Gerät – ohne Umleitungen, ohne Tracking und ohne Gebühren.

Die Verwendung von QR‑Codes ist lizenz‑ und kostenfrei.
Der Begriff „QR Code®“ ist jedoch ein eingetragenes Warenzeichen der Denso Wave Incorporated (externer Link).
Dies gilt unter anderem in Japan, den Vereinigten Staaten von Amerika, Australien und in Europa.

Die Technologie selbst ist frei nutzbar, aber die Markenbezeichnung „QR Code®“ unterliegt dem Markenschutz des Unternehmens.

Das Programm ist bewusst minimalistisch gehalten und lässt sich sehr einfach bedienen.

1. Text bei QRCode Text eingeben
2. Dateiname bei „Speichern als“ angeben, zur Auswahl des Pfades kann der Button mit den 3 Punkten gewählt werden.
3. Wenn gewünscht kann bei Farbe des QRCode, die Farbe des Codes ausgewählt werden.
4. Wenn gewünscht kann bei Farbe Hintergrund des QRCode, die Hintergrundfarbe des Codes ausgewählt werden.
5. Ist ein Logo gewünscht, kann ein Logo (oder Bild) ausgewählt werden.
6. Zuletzt kann die größe des Logos angegeben werden.
7. Nun auf Generieren klicken um den Code zu generieren.

Hinweise zur Größe des Logos

Die Logo‑Größe ist standardmäßig auf 20 % der QR‑Code‑Fläche eingestellt.
In der aktuellen Implementierung arbeitet der QR‑Code mit einer Fehlerkorrekturstufe von 25 % (ECC‑Level Q).

Da die Fehlerkorrektur maximal etwa 25 % der Modulfläche kompensieren kann, darf das Logo technisch bedingt nicht größer sein als dieser Anteil. Wird eine größere Fläche überdeckt, können die für die Decodierung erforderlichen Module nicht mehr vollständig rekonstruiert werden, was die Lesbarkeit des QR‑Codes beeinträchtigt oder vollständig verhindert.

Der Beitrag Kleiner QR Code Generator erschien zuerst auf .

Erstes Beispielprojekt zu Events

Wir erstellen eine Klasse Rechner, diese besitz eine Methode Namens Addiere. Diese Methode soll 2 Zahlen miteinander addieren und das Ergebnis über einem Event veröffentlichen.

class Rechner {
    // Delegat welches vom Event verwendet wird um den Erfolg einer Rechnung zu Signalisieren    
    public delegate void ErgebnisRechnungsErfolgHandler(int ergebnis);
    // Event 
    public event ErgebnisRechnungsErfolgHandler ErgebnisMelden;
    /// <summary>
    /// Addieren 
    /// </summary>
    /// <param name="a">Zahl 1</param>
    /// <param name="b">Zahl 2</param>
    /// <remarks>
    /// Statt einen Rückgabewert wird ein Event ausgelößt wenn die Berechnung beendet ist
    /// </remarks>
    public void Addiere(int a, int b)
    {
        int result = a + b;

        // Event auslösen (kurze schreibweise)
        ErgebnisMelden?.Invoke(result);
        // Event auslösen (lange schreibweise)
        //if (!(ErgebnisMelden == null))
        //    ErgebnisMelden(result);
    }
}

Was geschieht in der Klasse Rechner:
Zunächst wird ein Delegate deklariert: „public delegate void ErgebnisRechnungsErfolgHandler(int ergebnis);„. Um die Grundlagen von Delegates zu vertiefen, kann dies an im Beitrag Delegates (Grundlagen) nachgelesen werden.
Anschließend wird das Delegate mit einem Event verbunden, das von der Klasse aufgerufen wird: „public event ErgebnisRechnungsErfolgHandler ErgebnisMelden;„. Das Schlüsselwort event stellt sicher, dass sich externe Teilnehmer nur an diesem Delegate anmelden (+=) oder abmelden (-=) können, während die Kontrolle bei der Klasse Rechner als Auslöser bleibt.
Um das Event auszulösen kann einfach das Event, wie auch jede andere Methode aufgerufen werden mit „ErgebnisMelden(result)“.
Aber ACHTUNG, wenn das Event nicht implementiert worden ist, tritt hier ein Fehler auf da der „Zeiger“ des Events ins nichts zeigt. Aus diesem Grund habe ich hier im Code 2 Möglichkeiten aufgezeigt welche ein Absturz des Programmes verhindern.
Die erste Möglichkeit und kurze Möglichkeit ist „ErgebnisMelden?.Invoke(result);“. Wenn das Event Ereignismelden abonniert ist, dann wird das Event ausgeführt, sollte es nicht abonniert sein, wird das Event nicht ausgelöst.
Die zweite Möglichkeit ist für Beginner mit der Thematik einfacher verständlich.

if (!(ErgebnisMelden == null))
    ErgebnisMelden(result);

Es wird erst geprüft ob das Event ErgebnisMelden abonniert ist. Wenn es abonniert ist, wird es ausgeführt.

Wir haben nun die Klasse die Arbeitet, nun möchten wir natürlich auch das Programm erstellen welches die Methoden der Klasse anwendet.

static void Main(string[] args){
    Rechner rechne = new Rechner();                 // Rechner instanziieren
    rechne.ErgebnisMelden += Rechne_ErgebnisMelden; // Event abonnieren
    rechne.Addiere(1, 2);
    Console.WriteLine("Taste zum beenden.");
    Console.ReadKey();
}
private static void Rechne_ErgebnisMelden(int ergebnis){
    Console.WriteLine($"Ergebnis der Berechnung: {ergebnis}");
}

Was geschieht im Code?
Nach der Instanziierung der Klasse wird das in der Klasse definierte Event ErgebnisMelden mittels += abonniert: „rech.ErgebnisMelden += Rechne_ErgebnisMelden;„. Das abonnierte Event verweist anschließend auf die Methode, die mit dem Ergebnis weiterarbeitet.

Dieses kleine Beispiel zeigt wie Events funktionieren.
Im Beispielcode Download zu diesem Artikel ist ein 2tes (Windows Forms Projekt) enthalten. In diesem Windows Forms Projekt ist eine Klasse welche eine längere Aufgabe (Strings addieren) übernimmt und mittels Event zum einen den Status der Aufgabe (z.B. für einen Fortschrittsbalken) übergibt und das Ende der Aktion signalisiert. Als lange Aufgabe habe ich das Beispiel aus dem Eintrag Coding: Vergleich Strings und Array mit viel Inhalt verwendet.

Warum Events verwenden? Ich habe mal ein Modul erstellt, welches eine Kasse mit einem Bezahlterminal kommuniziert (Kartenzahlung), Während der Kartenzahlung werden diverse Informationen zwischen Kasse und Terminal hin und her gesandt (besonders dann wenn nicht das EC Terminal, sondern die Kasse den Zahlungsbeleg druckt). Damit die Kasse sämtliche Informationen am Kunden und Kassiererdisplay/Monitor anzeigt oder Zahlungsstatis, Start/Ende des Zahlungvorganges, etc. habe ich hier Events verwendet.

Quellcode des Beispiel zum Download.

Der Beitrag Event (Grundlagen) erschien zuerst auf .

Ein Delegate ist ein Datentyp, der eine Referenz auf Methoden speichern kann, wodurch Methoden wie Parameter behandelt werden können. Dies ermöglicht es, Methoden als Parameter an andere Methoden zu übergeben oder sie in Ereignstrukturen einzusetzen.

Kleines Beispiel der Verwendung eines einfachen Delegates

public delegate int Berechnung(int a, int b);   
// - Definition: Ein Delegate wird ähnlich einer Methode deklariert, lediglich ohne Rumpf

static void Main(string[] args){
    Berechnung addiere = (a, b) => a + b;
    Console.WriteLine("Ergebnis Addition: " + addiere(2, 2));

    Berechnung multipliziere = (c, d) => c * d;
    Console.WriteLine("Ergebnis Multiplikation: " + multipliziere (2, 2));

    Berechnung dividiere = (e, f) => e / f;
    Console.WriteLine("Ergebnis Dividition: " + dividiere(2, 2));

    Berechnung subtrahiere = (g, h) => g - h;
    Console.WriteLine("Ergebnis Subtration: " + subtrahiere(2, 2));
    Console.WriteLine("");
    Console.WriteLine("Zum Beenden Taste drücken");
    var nix = Console.ReadKey();
}

Was macht der obere Code?

Zuerst wird das Delegate mit der Deklaration „public delegate int Berechnung(int a int b);“ definiert. Das Delegate besitzt keinen Rumpfkörper, sondern lediglich die Parameter, die benötigt werden.
Interessant wird es bei der Zeile „Berechnung addiere = (a, b) => a + b;„:
Es wird eine Variable (addiere) des Delegatentyps Berechnung erstellt. Mit dem Lambda-Ausdruck ((a, b) => a + b) wird festgelegt, was mit den Variablen geschehen soll. In diesem kleinen Beispielprojekt wurde die kompakte Schreibweise gewählt. Lambda-Ausdrücke werden uns im Laufe der Zeit immer wieder begegnen. Innerhalb von Lambda-Ausdrücken können unter anderem auch ganze Methoden definiert werden. Dazu jedoch später mehr. Die Variable addiere ist nun eine Variable, die die Methode speichert. Wird also addiere mit den Parametern aufgerufen, wie in diesem Beispiel addiere(2, 2), werden die beiden Zahlen entsprechend dem Lambda-Ausdruck addiert.

In dem oben gegebenen Code verwende ich 1 Delegate um Berechnungsoperationen durchzuführen und schreibe per Lambda Funktion die genauen Rechenoperationen (Beispiele => a+b, =>c*d, etc.).

Multicast Delegates

Bei Multicast-Delegates können Delegates Methoden abonnieren, die nacheinander aufgerufen werden.

Für dieses Beispiel erstellen wir einfache Rechenoperationen (wie im Code 1) als Funktionen:

static int MCastAddiere(int a, int b) {
    Console.WriteLine($"Addiere: {a + b}");
    return a + b;
}
static int MCastSubtrahiere(int a, int b){
    Console.WriteLine($"Subtrahiere: {a - b}");
    return a - b;
}
static int MCastMultipliziere(int a, int b){
    Console.WriteLine($"Multipliziere: {a * b}");
    return a - b;
}
static int MCastDividiere(int a, int b){
    Console.WriteLine($"Dividiere: {a / b}");
    return a - b;
}

Um in den Beispielcode zu unterscheiden, habe ich an den Funktionen das Präfix „MCast“ verwendet.

Als nächsten wird ein Delegate erstellt, mit den Parametern, welche für die Berechnungen verwendet werden;

public delegate int Rechne(int a, int b);

Nun werden wir das Delegat vom Typ Rechne erstellen und alle Funktionen, welche wir ausführen möchten an das Delegat vom Typ Rechne hängen:

Rechne rechner = mCastAddiere;
rechner += mCastSubtrahiere;
rechner += mCastMultipliziere;
rechner += mCastDividiere;

Mit „+=“ werden Methoden hinzugefügt und mit „-=“ werden Methoden wieder entfernt.

Und nun Ausführen aller 4 Funktionen das Delegat ausführen:

int ergebnis = rechner(2, 2); // Ausführen aller Funktionen mittels Delegate
Console.WriteLine($"Letztes Ergebnis: {ergebnis}");
Console.WriteLine("Zum Beenden Taste drücken.");
Console.ReadKey();

Wie wir hier sehen, können Multicast-Delegates ein äußerst nützliches Werkzeug sein, um insbesondere wiederholende Aufgaben zu erleichtern. Wenn wir jedoch die Zeile „Console.WriteLine($“Letztes Ergebnis: {ergebnis}“);“ genauer betrachten, stellen wir fest, dass nur das letzte Ergebnis zurückgegeben wird. Daher sollten Multicast-Delegates vor allem bei Methoden mit void-Rückgabewerten verwendet werden, da der aufrufende Code lediglich den Wert der letzten Funktion erhält.

Multicast Delegaten mit Rückgabenwerten

Das ist etwas knifflig. Im ersten Multi Delegate-Beispiel sehen wir, dass Ergebnisse mit Ausnahme des letzten Ergebnisses verloren gehen. Dies ist in der Praxis nicht immer zielführend. Um später mit „allen“ Ergebnissen arbeiten zu können, müssen wir etwas Gehirnschmalz einsetzen.

public delegate int Berechnung(int a, int b);

static void Main(string[] args
    int addiere(int a, int b) => a + b;
    int multipliziere(int a, int b) => a * b;
    int dividiere(int a, int b) => a / b;
    int subtrahiere(int a, int b) => a - b;

    Berechnung rechne = addiere;
    rechne += multipliziere;
    rechne += dividiere;
    rechne += subtrahiere;
        
    int[] ergebnisse = rechne 
        .GetInvocationList()
        .Select(d => ((Berechnung)d)(6, 2))
        .ToArray();

    foreach(int ergebnis in ergebnisse)
        Console.WriteLine ($"Ergebnis: {ergebnis}");
    Console.WriteLine("Zum beenden Taste drücken.");
    ConsoleKeyInfo nix = Console.ReadKey();
}

Neu ist hier das Array vom Typ int:

int[] ergebnisse = rechne 
    .GetInvocationList()
    .Select(d => ((Berechnung)d)(6, 2))
    .ToArray();

GetInvocationList() gibt ein Array aller im Delegate enthaltenen Methoden zurück.
Mit Select(…) rufen wir gezielt jede Funktion auf, die im Delegate referenziert wird, und erhalten das Ergebnis.
Das Array „ergebnisse“ enthält nun alle Rückgabewerte, auf die wir nach Belieben zugreifen und diese entsprechend verwenden können.

So verlieren wir keinen Rückgabewert mehr.

Hier in diesen Beispielen werden nur Funktionen verwendet die Rechnen, natürlich ist es Möglich mehrere Funktionen zu verwenden, die auch unterschiedliche Dinge mit den Parametern machen.

Alle aufgeführten Listenings sind im Beispielprojekt enthalten.

Download zu Grundlagen Delegaten

Der Beitrag Delegates (Grundlagen) erschien zuerst auf .

• Abstrakte Klassen lassen sich nicht direkt instanziieren.
• Abstrakte Klassen können sowohl abstrakte als auch nicht-abstrakte Methoden, Funktionen und Attribute umfassen.
• Ermöglicht die Wiederverwendung von Quellcode.
• Dient als Basis für abgeleitete Klassen.
• Abstrakte Klassen dienen dazu, die Implementierung spezifischer Methoden, Funktionen und Attribute in abgeleiteten Klassen verbindlich vorzuschreiben.
• Abstrakte Klassen ermöglichen eine klare Struktur im Code, indem sie die direkte Instanziierung verhindern.
• Methoden, Funktionen und Attribute der abstrakten Klasse werden in den abgeleiteten Klassen gemeinsam genutzt, was die Wartbarkeit und Struktur des Codes erheblich vereinfacht.

Im ersten Teil der Grundlagen Verebung haben wir ein Beispielprojekt erstellt, das als abstrakte Klasse die Attribute, Methoden und Funktionen eines Fahrzeugs bereitstellt. Abgeleitete (Childs) sind „Auto“, „Motorrad“ und „LKW“. In diesem Beispielprojekt wird kurz erläutert, wie Methoden, Funktionen oder Attribute überladen werden können, wie etwa im Beispiel des Motorrads, das nicht rück fahren kann und bei dem die Methode „FahrenRueckwaerts“ überladen wurde. Sowie die Möglichkeit, je nach Fahrzeugtyp zusätzliche Methoden, Funktionen und Attribute hinzuzufügen (zum Beispiel bei einem LKW Kippen der Fahrerkabine).
Wer aufrichtig liest wird am Punkt 2 hängen geblieben sein „Abstrakte Klassen können sowohl abstrakte als auch nicht-abstrakte Methoden, Funktionen und Attribute umfassen“. Im Beispielcode sind in der Abstrakten Klasse „Fahrzeug“ nur nicht-abstrakte Methoden und Attribute verwendet worden. Was sind abstrakte Methoden?

Abstrakte Methoden (auch Funktionen und Attribute)

• Abstrakte Methoden werden nicht in der Basisklasse implementiert, nur die Methodensignatur ist vorhanden.
• Abstrakte Methoden müssen mittels Schlüsselwort override in der abgeleiteten Klasse (Child) überschrieben werden.
• Abstrakte Methoden können nur in abstrakte Klassen enthalten sein.
• Abstrakte Methoden müssen in der abgeleiteten Klasse (Child) implementiert werden.

In diesem Teil der Vererbung, werden wir die Klasse Fahrzeug um eine Funktion erweitern. Tanken! Jedes Fahrzeug benötigt Energie, egal ob Wasserstoff, Benzin/Diesel, oder geladen werden muss. Jeder dieser Vorgänge dauert seine Zeit und wird etwas anders ausgeführt und ist nicht bei jedem Fahrzeug gleich. Daher verwende ich mal die Funktion Tanken als Beispiel für abstrakte Funktionen.
Zuerst wird in der Abstrakte Klasse die Methoden Signatur festgelegt:

/// <summary>
/// Tanken
/// </summary>
/// <returns>Bei Erfolg true</returns>
/// <remarks>
/// Fahrzeuge müssen Tanken.
/// Ob Fossil oder regenerative Stoffe, ob Aufladen oder Wasserstoff, etc.
/// Bei abstrakten Methoden, Funktionen oder Attributen wird kein Code hinterlegt, lediglich die Signatur
/// </remarks>
public abstract bool Tanken();

Ab sofort ist es obligatorisch, die Funktion Tanken in allen abgeleiteten Klassen zu implementieren. Dadurch kann ich als Programmierer sicherstellen, dass bei neuen Fahrzeugen der oder die nächste Mitarbeiter:in die Funktion Tanken korrekt in neues Fahrzeug integriert.
Änderungen in den aktuellen abgeleiteten Klassen (als Beispiel nur die Änderung in der Klasse Auto) :

/// <summary>
/// Auto tanken
/// </summary>
/// <returns>Bei Erfolg true</returns>
public override bool Tanken()
{
    Console.WriteLine("Auto links neben der Tanksäule parken.");
    Console.WriteLine("Fahrer steigt aus.");
    Console.WriteLine("Fahrer öffnet Tankdeckel.");
    Console.WriteLine("Wagen wird mit Benzin getankt");
    Console.WriteLine("Fahrer schließt Tankdeckel.");
    Console.WriteLine("Fahrer bezahlt.");
    return true;
}

Eine Funktion Tanken muss nun in jeder abgeleiteten Klasse von „Fahrzeug“ implementiert werden.
Download bearbeiteter Code (Visual Studio).

Der Vorteil abstrakter Methoden besteht darin, dass sie eine klare Architektur erzwingen, während die einzelnen abgeleiteten Objekte die Methode entsprechend ihren Bedürfnissen implementieren können. Da die Methoden und Funktionen an die Anforderungen der Objekte angepasst sind, erfolgt auch die Wartung der Methoden und Funktionen innerhalb der abgeleiteten Klassen.

Der Beitrag Grundlagen Vererbung: Abstrakte Klassen erschien zuerst auf .

• Wartbarkeit: Es müssen nur an einer Stelle Änderungen vorgenommen werden.
• Strukturiert: Der Code bleibt übersichtlich und leicht verständlich.
• Weniger Fehleranfälligkeit: Code-Duplikate erhöhen das Risiko inkonsistente Änderungen.

Beispiel Non DRY Code (schlecht umgesetzt)

Beispiel einer einfachen Steuerberechnung mit einem festen Steuersatz von 19 %, ohne Berücksichtigung weiterer Steuerstufen (wie 7 %, 0 % oder 10,7 % ab 2025 liegt der Steuersatz für land- und forstwirtschaftliche Betriebe gemäß der Durchschnittsbesteuerung nach § 24 UStG bei 7,8 %, da er schrittweise gesenkt wurde).

public class Rechnung {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public double BerechneSteuer(double Betrag) {
            return Betrag * 0.19;
        }
        /// <summary>
        /// Bruttobetrag der Rechnung
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag) {
            return Betrag * BerechneSteuer(84.03);
        }
    }

    public class Bon
    {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public double BerechneSteuer(double Betrag)
        {
            return Betrag * 0.19;
        }
        /// <summary>
        /// Bruttobetrag des Bons
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * BerechneSteuer(84.03);
        }
    }
    public class Einkauf
    {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public double BerechneSteuer(double Betrag)
        {
            return Betrag * 0.19;
        }
        /// <summary>
        /// Bruttobetrag des Einkaufs
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * BerechneSteuer(84.03);
        }
    }

Beispiel DRY Prinzip

    public class Berechnungen
    {
        /// <summary>
        /// Volle USt aus dem Nettobetrag berechnen
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>USt Betrag</returns>
        public static double BerechneSteuer(double Betrag)
        {
            return Betrag * (double)0.19;
        }
    }
    public class Rechnung
    {
        /// <summary>
        /// Bruttobetrag der Rechnung
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * Berechnungen.BerechneSteuer(84.03);
        }
    }

    public class Bon
    {
        /// <summary>
        /// Bruttobetrag des Bons
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * Berechnungen.BerechneSteuer(84.03);
        }
    }
    public class Einkauf
    {
        /// <summary>
        /// Bruttobetrag des Einkaufs
        /// </summary>
        /// <param name="Betrag">Nettobetrag</param>
        /// <returns>Bruttobetrag</returns>
        public double Bruttobetrag(double Betrag)
        {
            return Betrag * Berechnungen.BerechneSteuer(84.03);
        }
    }

Unterschiede zwischen beiden Listenings

Non DRY Code:
Im Non-DRY-Ansatz wird der reguläre Steuerbetrag (19 %) sowohl in den Klassen für Rechnungen, Einkauf und Bons separat berechnet. Ändert sich der Steuersatz, muss die Anpassung an mehreren Stellen vorgenommen werden – für Rechnung, Einkauf und Bon. Falls zusätzlich eine Angebotsberechnung hinzugefügt wird, müsste die Steuerlogik ein weiteres Mal programmiert oder kopiert werden, was die Wartung erschwert.

DRY Code:
Im DRY-Code wird die Berechnungsfunktion zentral definiert. Diese Funktion wird in den Klassen Einkauf, Rechnung und Bon verwendet. Ändert sich der Steuersatz, muss die Funktion nur an einer Stelle angepasst werden, wodurch der Code wartungsfreundlicher bleibt.

Info:
Im Normalfall werden Steuersätze nicht fest im Code hinterlegt, da sie sich mit der Zeit ändern und für verschiedene Artikel unterschiedlich gelten können. Ein Beispiel dafür ist die Besteuerung in einem Schnellrestaurant: Speisen, die im Restaurant verzehrt werden, unterliegen dem regulären Steuersatz von 19 %, während außer Haus verkaufte Speisen mit dem ermäßigten Steuersatz von 7 % besteuert werden.

Der Beitrag DRY Prinzip (Don’t Repeat Yourself) erschien zuerst auf .