Viele Clean Code Prinzipien (wie z.B. DRY, KISS, YAGNI) sind weit verbreitet und den meisten Entwicklern bekannt. Diese Prinzipien sind intuitiv und schnell zu verstehen. Überraschenderweise ist eines der mächtigsten und wirkungsvollsten Clean Code Prinzipien aber relativ unbekannt. Es handelt sich um das IOSP. Das sogenannte Integration Operation Segregation Principle. Dieses Prinzip wird die Art und Weise wie Sie Software entwerfen entscheidend verändern.

Herausforderung

Verständlicher und leicht zu wartender Quellcode ist der Traum eines jeden Softwareentwicklers. Zu Beginn der Umsetzung ist das auch meist der Fall. Unser Programmcode ist noch übersichtlich und leicht zu verstehen:

Mit zunehmender Zeit, mutiert Programmcode jedoch immer weiter zu Spaghetti-Code. Schon nach kurzer Zeit sieht der oben gezeigte Code dann so aus:

Warum ist das so? Der Grund dafür ist, dass die primäre Intention des Codes, durch (notwendige) Sekundäraspekte verschmutzt wird. Sekundäraspekte sind Aspekte wie Validierung, Logging, Asynchronität, Fehlerbehandlung usw. Kurz gesagt alle Aspekte, die nicht primär der Erfüllung unserer Business-Anforderungen, dienen.

Das sogenannte Integration Operation Segregation Principle ist eines der Schlüsselprinzipien mit dessen Hilfe wir zu verständlichem Programmcode zurückkehren können. Dieses Prinzip wird die Art und Weise wie Sie Software entwerfen entscheidend verändern!

Erklärung des IOSP

Definition

Das Integration Operation Segregation Principle, zielt darauf ab den Programmcode in Integrationsslogik (Integration) und Operationslogik (Operation) aufzutrennen (engl. segregate).

Unter Operationslogik verstehen wir den Teil unserer Geschäftslogik, der das „wie“ im Detail beschreibt. Dabei kommen alle bekannten Kontrollstrukturen (if, else, …), Operatoren oder Datentypen usw. zum Einsatz.

Die Integrationslogik ist der Teil unserer Anwendung, der keine eigene „Berechnungslogik“ enthält, sondern nur noch Operationslogik (oder andere Integrationslogik) aufruft, also nur aus Funktionsaufrufen besteht.

Beispiel

Schauen wir uns das IOSP anhand eines einfachen Hello World Beispiels an. Die Besonderheit in unserem Beispiel ist, wir wollen in Abhängigkeit eines Konfigurationsschalters den Text Hello World in Großbuchstaben oder in Kleinbuchstaben ausgeben.

class Program
{
    static void Main(string[] args)
    {
        var textErzeugen = new TextErzeugen(new TextGrossSchreiben(), new ConfigService());

        Console.WriteLine(textErzeugen.Erzeugen());

        Console.ReadLine();
    }
}

public class TextErzeugen : ITextErzeugen
{
    private readonly ITextGrossSchreiben _textGrossSchreiben;
    private readonly IConfigService _configService;
    private const string Text = "Hello World";

    public TextErzeugen(ITextGrossSchreiben textGrossSchreiben, IConfigService configService) 
    {
        _textGrossSchreiben = textGrossSchreiben;
        _configService = configService;
    }

    public string Erzeugen()
    {
        if (_configService.SollTextGrossGeschriebenWerden)
            return _textGrossSchreiben.GrossSchreiben(Text);

        return Text;
    }
}

public class TextGrossSchreiben : ITextGrossSchreiben
{
    public string GrossSchreiben(string text)
    {
        return text.ToUpper();
    }
}

Natürlich könnte dieses einfache Beispiel auch komplette in einer Methode implementiert sein. Für Lernzwecke ist aber bereits eine gewisse Modularisierung vorgesehen. Aktuell gibt es noch keine Unterscheidung zwischen Integrationslogik und Operationslogik. So wird beispielsweise in der Klasse TextErzeugen der Config Service aufgerufen (Integrationslogik). Gleichzeitig liegt durch das if Statement aber auch Operationslogik vor. Ähnlich verhält es sich mit der Main Methode. Der Aufruf von textErzeugen.Erzeugen() ist Integrationslogik. Das Ausgeben auf der Konsole ist hingegen Operationslogik.

Wir gehen einen Schritt weiter und werfen einen Blick auf die Unit-Tests der Klasse TextErzeugen:

[TestClass]
public class TextErzeugenTests
{
    private ITextErzeugen _target;
    private IConfigService _configService;

    [TestInitialize]
    public void SetUp()
    {
        var textGrossSchreiben = MockRepository.GenerateStub<ITextGrossSchreiben>();
        _configService = MockRepository.GenerateStub<IConfigService>();

        textGrossSchreiben.Stub(x => x.GrossSchreiben("Hello World")).IgnoreArguments().Return("HELLO WORLD");

        _target = new TextErzeugen(textGrossSchreiben, _configService);
    }

    [TestMethod]
    public void Erzeugen_GrossSchreibenAktiviert_ErzeugtHelloWorldTextGroß()
    {
        _configService.Stub(c => c.SollTextGrossGeschriebenWerden).Return(true);

        var result = _target.Erzeugen();

        Assert.AreEqual("HELLO WORLD", result);
    }

    [TestMethod]
    public void Erzeugen_GrossSchreibenDeaktiviert_ErzeugtHelloWorldTextKlein()
    {
        _configService.Stub(c => c.SollTextGrossGeschriebenWerden).Return(false);

        var result = _target.Erzeugen();

        Assert.AreEqual("Hello World", result);
    }
}

In den Unit-Tests, wird (in Abhängigkeit des Konfigurationsschalters) geprüft, ob der Text groß oder klein geschrieben werden soll. Bedenken Sie aber, dass wir eigentlich das Erzeugen von Text testen möchten. Stattdessen testen wir, dass die Funktion das Ergebnis liefert, welches wir im Stub selbst vorgegeben haben – was wird hier also überhaupt getestet? Es handelt sich schon gar nicht mehr um einen einfachen Unit-Test, sondern vielmehr um einen Integrationstest. Die Abhängigkeiten unserer zu testenden Klasse sind ein Problem. Mit weiteren Abhängigkeiten wird der Test noch komplexer. Endlose Mocking und Stubbing Orgien sind die Konsequenz. Wenn wir die Topologie unseres Programms bzw. dessen Programmteile betrachten, fällt schnell auf, dass Integrationslogik und Operationslogik vermischt sind:

Lösung

Die Lösung unserer o.g. Probleme liegt in der konsequenten Anwendung des IOSP. Wir trennen strikt zwischen Integrationslogik und Operationslogik und erhalten folgende Programmtopologie:

Es ist deutlich zu sehen, dass sich die Operationslogik (das „WIE“) immer in den Blättern des „Programmtopologiebaumes“ befindet. Diese Operationslogik ist durch Anwendung des IOSP nun sehr klar und erfüllt ausschließlich den im Namen der Klasse / Funktion definierten Zweck:

public class TextErzeugen : ITextErzeugen
{
    public string Erzeugen()
    {
        return "Hallo Welt!";
    }
}

public class ConfigService : IConfigService
{
    public bool SollTextGrossGeschriebenWerden()
    {
        return true;
    }
}

public class TextGrossSchreiben : ITextGrossSchreiben
{
    public string GrossSchreiben(string text, bool grossSchreiben)
    {
        return grossSchreiben ? text.ToUpper() : text;
    }
}

Da die Abhängigkeiten verschwunden sind, lassen sich die „Operationsfunktionen“ auch ganz einfach Unit-Testen.

Die Klarheit der Funktionen mit Operationen hat im Vergleich zum letzten Beispiel deutlich zugenommen. Das trifft auch auf die Klassen mit reiner Integrationslogik zu, wie z.B. der HelloWorld Klasse:

public class HelloWorld : IHelloWorld
{
    private readonly ITextErzeugen _textErzeugen;
    private readonly IConfigService _configService;
    private readonly ITextGrossSchreiben _textGrossSchreiben;
    private readonly ITextAusgeben _textAusgeben;

    public HelloWorld(
        ITextErzeugen textErzeugen,
        IConfigService configService,
        ITextGrossSchreiben textGrossSchreiben,
        ITextAusgeben textAusgeben)
    {
        _textErzeugen = textErzeugen;
        _configService = configService;
        _textGrossSchreiben = textGrossSchreiben;
        _textAusgeben = textAusgeben;
    }

    public void SayHello()
    {
        var text = _textErzeugen.Erzeugen();
        var grossSchreiben = _configService.SollTextGrossGeschriebenWerden();
        var grosserText = _textGrossSchreiben.GrossSchreiben(text, grossSchreiben);

        _textAusgeben.Ausgeben(großerText);
    }
}

Vergleichen Sie jetzt noch einmal die erste Version des vermeintlich einfachen HelloWorld Beispiels mit dieser optimierten Version! Wunderschön. Das Programm – besonders die SayHello Methode – ist deutlich einfacher und verständlicher. Sie besteht aus reinen Funktionsaufrufen. Wir können diese Funktion von oben nach unten „lesen“ und verstehen, ohne Code zu „interpretieren“.

Fazit

Das IOSP trennt die Intention (WAS wollen wir tun) von der tatsächlichen Ausführung (WIE wollen wir es tun). Das führt zu lesbarem und verständlichem Programmcode. Das IOSP ist eines der Schlüsselprinzipien um Spaghetti-Code zu vermeiden. Und ja, auch Sie können das! Das IOSP bietet noch viel mehr Vorteile, die den Rahmen des Blogartikels sprengen würden.

Unser Beispiel war einfach, dennoch können Sie das IOSP in jedem Programm und auf eine Vielzahl von Problemen anwenden! Die Umsetzung erfordert allerdings Übung. Beim Design von Software gibt Vorgehensmuster, um IOSP-kompatiblen Code zu erhalten. Sie sollten sich dabei von einem erfahrenen Coach begleiten lassen.