Diese Antwort beantwortet Ihre Frage zwar nicht direkt , aber ich bin der Meinung, dass ich es versäumen würde, sie zu übergehen, ohne zu erwähnen, wie man sie verbessern kann (da es, wie Sie sagen, ein Anti-Pattern sein kann). Ich hoffe, dass Sie und andere Leser von diesem zusätzlichen Kommentar profitieren können, wie man "Tramp-Daten" vermeidet (wie Bob Dalgleish es so hilfreich für uns nannte).
Ich stimme Antworten zu, die darauf hindeuten, etwas mehr OO zu tun, um dieses Problem zu vermeiden. Eine andere Möglichkeit, diese Übergabe von Argumenten zu reduzieren, ohne nur zu "Übergeben Sie eine Klasse, in der Sie früher viele Argumente übergeben haben! " Zu wechseln, besteht darin, einige Schritte Ihres Prozesses auf der höheren Ebene statt auf der niedrigeren Ebene auszuführen einer. Hier ist zum Beispiel ein Vorher- Code:
public void PerformReporting(StuffRepository repo, string desiredName) {
var stuffs = repo.GetStuff(DateTime.Now());
FilterAndReportStuff(stuffs, desiredName);
}
public void FilterAndReportStuff(IEnumerable<Stuff> stuffs, string desiredName) {
var filter = CreateStuffFilter(FilterTypes.Name, desiredName);
ReportStuff(stuffs.Filter(filter));
}
public void ReportStuff(IEnumerable<Stuff> stuffs) {
stuffs.Report();
}
Beachten Sie, dass dies umso schlimmer wird, je mehr Dinge erledigt werden müssen ReportStuff
. Möglicherweise müssen Sie die Instanz des Reporters übergeben, den Sie verwenden möchten. Und alle möglichen Abhängigkeiten, die weitergegeben werden müssen, funktionieren in verschachtelten Funktionen.
Mein Vorschlag ist, all das auf eine höhere Ebene zu heben, wo das Wissen über die Schritte Leben in einer einzelnen Methode erfordert, anstatt über eine Kette von Methodenaufrufen verteilt zu sein. Natürlich wäre es in echtem Code komplizierter, aber das gibt Ihnen eine Idee:
public void PerformReporting(StuffRepository repo, string desiredName) {
var stuffs = repo.GetStuff(DateTime.Now());
var filter = CreateStuffFilter(FilterTypes.Name, desiredName);
var filteredStuffs = stuffs.Filter(filter)
filteredStuffs.Report();
}
Beachten Sie, dass der große Unterschied darin besteht, dass Sie die Abhängigkeiten nicht durch eine lange Kette führen müssen. Selbst wenn Sie nicht nur auf eine Ebene, sondern auf einige Ebenen abflachen, haben Sie eine Verbesserung erzielt, wenn diese Ebenen auch eine gewisse "Abflachung" erzielen, sodass der Prozess als eine Reihe von Schritten auf dieser Ebene angesehen wird.
Während dies noch prozedural ist und noch nichts in ein Objekt umgewandelt wurde, ist es ein guter Schritt, um zu entscheiden, welche Art von Kapselung Sie erreichen können, indem Sie etwas in eine Klasse umwandeln. Die tief verketteten Methodenaufrufe im vorherigen Szenario verbergen die Details dessen, was tatsächlich passiert, und können dazu führen, dass der Code sehr schwer zu verstehen ist. Obwohl Sie dies übertreiben und den Code auf höherer Ebene über die Dinge informieren können, die er nicht wissen sollte, oder eine Methode entwickeln können, die zu viele Dinge tut und so gegen das Prinzip der einmaligen Verantwortung verstößt, habe ich im Allgemeinen festgestellt, dass das Reduzieren von Dingen ein wenig hilfreich ist in der Klarheit und bei der schrittweisen Änderung in Richtung eines besseren Codes.
Beachten Sie, dass Sie dabei die Testbarkeit berücksichtigen sollten. Die verketteten Methodenaufrufe erschweren das Testen von Units tatsächlich, da Sie für das zu testende Segment keinen guten Einstiegs- und Ausstiegspunkt in der Assembly haben. Beachten Sie, dass Ihre Methoden mit dieser Reduzierung, da sie nicht mehr so viele Abhängigkeiten aufweisen, einfacher zu testen sind und nicht so viele Mocks erfordern!
Ich habe kürzlich versucht, Komponententests zu einer Klasse hinzuzufügen (die ich nicht geschrieben habe), die ungefähr 17 Abhängigkeiten hat, die alle verspottet werden mussten! Ich habe noch nicht alles geklappt, aber ich habe die Klasse in drei Klassen aufgeteilt, die sich jeweils mit einem der einzelnen Nomen befassten, und die Abhängigkeitsliste auf 12 für das schlechteste und ungefähr 8 für das schlechteste Beste.
Durch die Testbarkeit werden Sie gezwungen , besseren Code zu schreiben. Sie sollten Komponententests schreiben, da Sie dadurch Ihren Code anders überdenken und von Anfang an besseren Code schreiben, unabhängig davon, wie wenige Fehler Sie möglicherweise hatten, bevor Sie die Komponententests geschrieben haben.