Ereignisgesteuertes Programmieren: Wann lohnt es sich?

Ok, ich weiß, der Titel dieser Frage ist fast identisch mit Wann sollte ich ereignisbasierte Programmierung verwenden? Die Antworten auf diese Frage haben mir jedoch nicht bei der Entscheidung geholfen, ob ich Ereignisse in dem speziellen Fall verwenden soll, in dem ich mich befinde.

Ich entwickle eine kleine Anwendung. Es ist eine einfache App, deren Funktionalität zum größten Teil einfach CRUD ist.

Bei bestimmten Ereignissen (beim Ändern bestimmter Daten) muss die Anwendung eine lokale Kopie dieser Daten in eine Datei schreiben. Ich bin mir nicht sicher, wie ich das am besten umsetzen kann. Ich kann:

• Lösen Sie Ereignisse aus, wenn die Daten geändert werden, und binden Sie eine Antwort (generieren Sie die Datei) an solche Ereignisse. Alternativ können Sie das Beobachtermuster implementieren. Das scheint unnötig kompliziert zu sein.
• Rufen Sie den dateierzeugenden Code direkt aus dem Code auf, der die Daten ändert. Viel einfacher, aber es scheint falsch, dass die Abhängigkeit auf diese Weise sein sollte, das heißt, es scheint falsch, dass die Kernfunktionalität der App (Code, der Daten ändert) mit diesem zusätzlichen Vorteil (Code, der eine Sicherungsdatei generiert) gekoppelt werden sollte. Ich weiß jedoch, dass sich diese App nicht zu einem Zeitpunkt entwickeln wird, an dem diese Kopplung ein Problem darstellt.

Was ist in diesem Fall der beste Ansatz?

Befolgen Sie das KISS-Prinzip: Halten Sie es einfach, dumm oder das YAGNI-Prinzip: Sie werden es nicht brauchen.

Sie können den Code wie folgt schreiben:

void updateSpecialData() {
    // do the update.
    backupData();
}

Oder Sie können Code schreiben wie:

void updateSpecialData() {
     // do the update.
     emit SpecialDataUpdated();
}

void SpecialDataUpdatedHandler() {
     backupData();
}

void configureEventHandlers() {
     connect(SpecialDataUpdate, SpecialDataUpdatedHandler);
}

Wenn kein zwingender Grund vorliegt, etwas anderes zu tun, folgen Sie dem einfacheren Weg. Techniken wie die Ereignisbehandlung sind leistungsstark, erhöhen jedoch die Komplexität Ihres Codes. Es erfordert mehr Code, um zu funktionieren, und es erschwert die Verfolgung der Code-Vorgänge.

Ereignisse sind in der richtigen Situation sehr kritisch (stellen Sie sich vor, Sie würden versuchen, die Benutzeroberfläche ohne Ereignisse zu programmieren!). Verwenden Sie sie jedoch nicht, wenn Sie stattdessen KISS oder YAGNI können.

Das von Ihnen beschriebene Beispiel für einfache Daten, bei denen die Änderung einen gewissen Effekt auslöst, kann mit dem Beobachter-Entwurfsmuster perfekt implementiert werden :

• Dies ist einfacher zu implementieren und zu warten als vollständiger ereignisgesteuerter Code.
• Die Kopplung zwischen Subjekt und Betrachter kann abstrakt sein, was die Trennung der Anliegen erleichtert.
• Es ist ideal für eine bis viele Beziehung (die Probanden haben einen oder mehrere Beobachter).

Ein ereignisgesteuerter Ansatz lohnt sich für komplexere Szenarien, in denen viele verschiedene Wechselwirkungen auftreten können, in einem Many-to-Many-Kontext oder wenn Kettenreaktionen vorgesehen sind (z. B. informiert ein Subjekt einen Beobachter, der in einigen Fällen die Daten ändern möchte) Fach oder andere Fächer)

Wie Sie sagen, sind Ereignisse ein großartiges Werkzeug, um die Kopplung zwischen Klassen zu verringern. Es kann zwar erforderlich sein, zusätzlichen Code in einigen Sprachen zu schreiben, ohne dass Ereignisse unterstützt werden, dies verringert jedoch die Komplexität des Gesamtbilds.

Ereignisse sind wohl eines der wichtigsten Werkzeuge in OO (laut Alan Kay kommunizieren Objekte durch das Senden und Empfangen von Nachrichten ). Wenn Sie eine Sprache verwenden, die Ereignisse unterstützt, oder Funktionen als erstklassige Bürger behandelt, ist ihre Verwendung ein Kinderspiel.

Sogar in Sprachen ohne eingebaute Unterstützung ist die Menge an Boilerplate für etwas wie das Observer-Muster ziemlich gering. Möglicherweise finden Sie irgendwo eine anständige generische Eventing-Bibliothek, die Sie in all Ihren Anwendungen verwenden können, um das Boilerplate zu minimieren. (Ein generischer Ereignisaggregator oder Ereignismediator ist in nahezu jeder Anwendung nützlich.)

Lohnt es sich in einer kleinen Anwendung? Ich würde definitiv ja sagen .

• Wenn Sie die Klassen voneinander entkoppelt halten, bleibt Ihr Klassenabhängigkeitsdiagramm übersichtlich.
• Klassen ohne konkrete Abhängigkeiten können isoliert getestet werden, ohne dass andere Klassen in den Tests berücksichtigt werden.
• Klassen ohne konkrete Abhängigkeiten erfordern weniger Komponententests für eine vollständige Abdeckung.

Wenn Sie denken "Oh, aber es ist wirklich nur eine sehr kleine Anwendung, es ist wirklich nicht so wichtig" , bedenken Sie:

• Kleine Anwendungen werden manchmal später mit größeren Anwendungen kombiniert.
• Kleine Anwendungen enthalten wahrscheinlich mindestens einige Logikkomponenten oder Komponenten, die später möglicherweise in anderen Anwendungen wiederverwendet werden müssen.
• Die Anforderungen für kleine Anwendungen können sich ändern, sodass eine Umgestaltung erforderlich ist. Dies ist einfacher, wenn vorhandener Code entkoppelt wird.
• Weitere Funktionen können später hinzugefügt werden, sodass der vorhandene Code erweitert werden muss. Dies ist auch viel einfacher, wenn der vorhandene Code bereits entkoppelt ist.
• Bei lose gekoppeltem Code dauert das Schreiben im Allgemeinen nicht viel länger als bei fest gekoppeltem Code. Bei eng gekoppeltem Code dauert das Umgestalten und Testen jedoch viel länger als bei lose gekoppeltem Code.

Insgesamt sollte die Größe einer Anwendung kein entscheidender Faktor dafür sein, ob Klassen lose gekoppelt bleiben sollen. SOLID-Prinzipien gelten nicht nur für große Anwendungen, sondern für Software und Codebasen in jeder Größenordnung.

Tatsächlich sollte die Zeitersparnis beim Unit-Testen Ihrer lose gekoppelten Klassen für sich genommen die zusätzliche Zeit ausgleichen, die zum Entkoppeln dieser Klassen aufgewendet wurde.

Das Beobachtermuster kann viel kleiner implementiert werden, als der Wikipedia-Artikel (oder das GOF-Buch) es beschreibt, vorausgesetzt, Ihre Programmiersprachen unterstützen so etwas wie "Rückrufe" oder "Delegierte". Übergeben Sie einfach eine Callback-Methode in Ihren CRUD-Code (die Observer-Methode, die entweder eine generische Methode zum Schreiben in eine Datei oder eine leere Methode sein kann). Anstelle von "Ereignisauslösung" rufen Sie einfach diesen Rückruf auf.

Der resultierende Code ist nur minimal komplexer als der direkte Aufruf des dateierzeugenden Codes, jedoch ohne die Nachteile einer engen Kopplung nicht verwandter Komponenten.

Das bringt Ihnen "das Beste aus beiden Welten", ohne die Entkopplung für "YAGNI" zu opfern.