Woran erkenne ich, ob die Software stark gekoppelt ist?

Ich kenne den Begriff "stark gekoppelt", bin aber neugierig, ob es Anzeichen (Codegerüche) gibt, die darauf hinweisen, dass der Code stark gekoppelt ist. Ich arbeite derzeit mit Java EE, dies kann jedoch für jede Sprache gelten.

Bearbeiten:

Bei Interesse klingt dieser Artikel hilfreich: Im Streben nach Codequalität: Vorsicht vor dem engen Paar! (IBM)

Der Hauptindikator für schlecht gekoppelte Module sind meiner Meinung nach bilaterale Abhängigkeiten. Zum Beispiel ruft Modul1 eine Funktion in Modul2 und Modul2 eine Funktion in Modul1 auf.

Die meisten Schnittstellen sollten unidirektional sein. Wenn das aufgerufene Modul einige Informationen an das aufrufende Modul übergeben muss, die nicht als Teil des Aufrufs zurückgegeben werden, sollte es eine Art Nachrichtenübergabe- oder Ereignisauslösemechanismus verwenden, z. B. eine Nachrichtenwarteschlange. Im Idealfall sollte das Handle zur Nachrichtenübergabeschnittstelle während eines Initialisierungs- oder Registrierungsprozesses übergeben werden. Dies abstrahiert die Schnittstelle vollständig, so dass es dem Modul eigentlich egal ist, für wen das Ereignis ist ... daher ist es entkoppelt.

Eine andere Anzeige ist, wenn ein Modul ständig ein anderes Modul für einen bestimmten Datensatz aufruft. Dies sollte Sie fragen lassen, wem der Datensatz tatsächlich gehört. Warum muss dieses Modul immer Daten anzeigen, die zu einem anderen Modul gehören?

Ein drittes Werkzeug ist sozusagen die Frage: "Kann ich dieses Modul herausziehen und ersetzen, ohne dass Änderungen an anderen Modulen erforderlich sind?

Dies ist keine vollständige Liste, aber es sind die drei wichtigsten Fragen, die ich mir beim Entwerfen von Software stelle.

Das alte Design-Sprichwort lautet: "Sie können Ihre Freunde berühren, und Sie können Ihre Privatsphäre berühren. Aber Sie können die Privatsphäre Ihrer Freunde nicht berühren." Das lässt sich auf den Punkt bringen.

Anzeichen für stark gekoppelten Code sind sehr große Schnittstellen, über die die Benutzer über private Details der Implementierung informiert werden, und Objekte, die scheinbar "viel voneinander wissen". Es gibt Tools für die automatische Analyse, die Code kennzeichnen, der für Sie eng gekoppelt aussieht. Eine zufällige Liste finden Sie unter http://www.scitools.com/features/metricsintro.php . (Ich habe keine Ahnung, wie gut es funktioniert. Es ist gerade in einer Google-Suche ziemlich hoch aufgetaucht.)

Versuchen Sie, einige Komponententests für Klassen zu schreiben. Wenn Sie Klassen nicht einfach testen können, ohne jede Menge Support-Klassen oder eine DB / UI erstellen / verspotten zu müssen, ist dies ein sicheres Zeichen für schlechte Kopplung / Abhängigkeiten.

Es ist auch eine der besten Lösungen, aber Sie müssen es während des Codierens tun (wie bei TDD), um ehrlich zu bleiben.

Das offensichtliche Zeichen für mich ist, dass alles öffentlich ist.

Das andere Zeichen ist das Gesetz der Demeter-Verstöße - übermäßig viele this.SomeObj.SomeProp.SomeProp-Verweise auf nicht fließende Schnittstellen.

Ich habe mal gesehen, was ich seitdem eine "Puppenmeisterklasse" genannt habe, die ein Dateneingabeformular im laufenden Betrieb erstellt hat. Es gab mehrere andere Verstöße gegen das Softwaredesign, sodass eine übermäßige Kopplung das geringste Problem darstellte.

Beim Abrufen von Daten von den Steuerelementen, die es erstellt hat, sah das folgendermaßen aus:

var control = activeDataEntryControl as CustomTextBox;
if (control != null)
   result = control.NestedTextBox.Text;

/* several other controls */

Der Ripple-Effekt .

Jede Änderung wirkt sich auf alle eng gekoppelten Module aus.

Das "Open-Closed" -Prinzip wurde dadurch verletzt, dass es nicht richtig geschlossen ist und Änderungen auslaufen.

Überprüfen Sie die Anzahl der # include / Importe usw. zwischen Klassen / Paketen / DLLs / Gläsern / Dingsbums. Versuchen Sie, mental, manuell oder mit einem Werkzeug ein Diagramm davon zu zeichnen.

• Wenn dieser Graph dicht ist (dh viele Verbindungen überall), ist Ihr System monolithisch und stark gekoppelt.
• Wenn es klar in Schichten unterteilt ist, keine Verbindungen zwischen den Schichten und nur wenige Verbindungen bestehen, haben Sie ein modulares und entkoppeltes System.

Wenn Sie eine Funktion nicht implementieren können, weil Sie keine Ahnung haben, wo eine bestimmte Verantwortung liegt, ist Ihr System zu eng miteinander verbunden.

Bei sehr einfachen Zeichen sollten Sie die Anzahl der Schnittstellen und deren Verwendung zwischen Klassen verschiedener Pakete untersuchen (normalerweise enthält lose gekoppelter Code Schnittstellen und es gibt nur eine begrenzte direkte Interaktion zwischen den einzelnen Klassen in verschiedenen Paketen) Wird verwendet, um andere Klassen zu gruppieren (in locker gekoppeltem Code erfolgt die tatsächliche Interaktion zwischen Klassen mit unterschiedlichen Aufgaben durch Schnittstellenfunktionen oder durch Funktionen allgemeinerer / gruppierender Klassen) oder um öffentliche Variablen innerhalb von Klassen zu nummerieren (mehr locker, weniger oder gar keine öffentlichen Variablen) ).

Fast alle Codegerüche weisen auf eine überflüssige Kopplung hin. Ich nehme an, der Geruch, der am meisten auf eine Kopplung hindeutet, ist "Unangemessene Intimität" (mein Lieblingsgeruch).

Ich nehme an, dass eine andere vernünftige Methode zum Messen darin besteht, die Linien in Ihrem UML-Diagramm zu zählen. Wenn Sie N Objekte und N ^ N (oder mehr) Zeilen dazwischen haben, ist Ihr Code so ziemlich maximal gekoppelt. N Zeilen wären wahrscheinlich so minimal wie möglich.