Benannte Argumente (Parameter) als Lesbarkeitshilfe

Vor langer Zeit habe ich viel in ADA programmiert, und es war normal, beim Aufrufen einer Funktion Argumente zu benennen - SomeObject.DoSomething (SomeParameterName => someValue);

Jetzt, da C # benannte Argumente unterstützt, denke ich darüber nach, in Situationen, in denen es möglicherweise nicht offensichtlich ist, was ein Argument bedeutet, zu dieser Gewohnheit zurückzukehren.

Sie könnten argumentieren, dass es immer offensichtlich sein sollte, was ein Argument bedeutet, aber wenn Sie ein boolesches Argument haben und Anrufer "true" oder "false" übergeben, macht das Qualifizieren des Werts mit dem Namen die Aufrufsite lesbarer.

contentFetcher.DownloadNote (Hinweis, Handbuch: true);

Ich denke, ich könnte Enums erstellen, anstatt true oder false zu verwenden (manuell, in diesem Fall automatisch).

Was halten Sie davon, gelegentlich benannte Argumente zu verwenden, um das Lesen von Code zu erleichtern?

Dies wurde in der Entwicklung von C ++ vorgeschlagen, und Stroustrup erörtert dies in seinem "Design and Evolution of C ++", Seite 153 und folgende. Der Vorschlag war wohlgeformt und stützte sich auf frühere Erfahrungen mit Ada. Es wurde nicht adoptiert.

Der Hauptgrund war, dass niemand Funktionen mit einer großen Anzahl von Parametern fördern wollte. Jede zusätzliche Funktion in einer Sprache kostet etwas, und es bestand kein Wunsch, eine Funktion hinzuzufügen, um das Schreiben fehlerhafter Programme zu vereinfachen.

Es wurden auch Fragen zu den kanonischen Parameternamen aufgeworfen, insbesondere in der üblichen Konvention für Header und Codedateien. Einige Organisationen hatten längere und aussagekräftigere Parameternamen in der .h-Datei und kürzere und einfacher einzugebende Namen in der .cpp-Datei (Ersatzdateisuffixe nach Wunsch). Das Erfordernis, dass diese identisch sind, würde zusätzliche Kosten für die Kompilierung verursachen, und das Verwechseln von Namen zwischen Quelldateien könnte subtile Fehler verursachen.

Es kann auch mithilfe von Objekten anstelle von Funktionsaufrufen behandelt werden. Erstellen Sie anstelle eines GetWindow-Aufrufs mit einem Dutzend Parametern eine Window-Klasse mit einem Dutzend privater Variablen und fügen Sie bei Bedarf Setter hinzu. Durch Verketten der Setter ist es möglich, so etwas wie zu schreiben my_window.SetColor(green).SetBorder(true).SetBorderSize(3);. Es ist auch möglich, verschiedene Funktionen mit unterschiedlichen Standardeinstellungen zu haben, die die Funktion aufrufen, die die Arbeit tatsächlich erledigt.

Wenn Sie sich nur Sorgen über den Dokumentationseffekt von machen contentFetcher.DownloadNote(note, manual : true);, können Sie immer so etwas schreiben contentFetcher.DownloadNote(note, /* manual */ true);, sodass es in der Dokumentation nicht einmal sehr hilfreich ist.

Ich denke, hier geht es darum, schlechten Code besser lesbar zu machen, anstatt um „Best Practice“.

Eine Methode (oder ein Auftragnehmer) mit 20 Parametern ist ein „schlechter Geruch“ und wahrscheinlich auf ein Problem in Ihrem Design zurückzuführen. Wenn ich jedoch gezwungen bin, an Code zu arbeiten, wenn Methoden viele Parameter annehmen, machen benannte Parameter den Code weniger schwer verständlich.

Wenn Methoden nur 1 oder 2 Parameter haben und aus dem Methodennamen ersichtlich ist, um welche Parameter es sich handelt, fügt der benannte Parameter nichts hinzu. Dies ist der ideale Fall.

Wenn der gesamte Code, an dem Sie arbeiten, als Teil des Buches „ Clean Code “ geschrieben ist, haben Sie nur sehr wenig Verwendung für benannte Parameter, wir leben jedoch in der realen Welt.

Ich bin damit einverstanden, dass das Hinzufügen des Parameternamens die Lesbarkeit verbessert. Die meisten Bücher, die ich gelesen habe, scheinen jedoch boolesche Schalter als schlechte Praxis zu betrachten. Ich mache das manchmal:

public Content DownloadNote(Note note)
{
    return downloadNote(note, manual: false);
}

public Content DownloadNoteManually(Note note)
{
    return downloadNote(note, manual: true);
}

Dies gibt Ihnen mehr Flexibilität bei der Implementierung Ihrer API. Sie können damit auch den Fall steuern, in dem Sie mehrere boolesche Schalter haben, aber nicht alle gleichzeitig aktiv sein können.

Ich glaube fest an benannte Parameter in Situationen, in denen die Typen und die Semantik aus dem Namen der Methode nicht ersichtlich sind. Ich habe die Erfahrung gemacht, dass nur wenige Leute die Dokumentation lesen.

Allerdings sollten benannte Parameter keine Alternative zu sinnvollen Argumentlisten, der Verwendung von Hilfsobjekten (um semantisch verwandte Argumente zu "verknüpfen") und gegebenenfalls der Verwendung von Aufzählungen sein.

Ich denke, dies ist nützlicher in Nicht-OO-Sprachen, in denen Sie möglicherweise eine Funktion haben, die auf verschiedene, etwas unterschiedliche Arten etwas tun muss, und die Art und Weise, wie sie bestimmt, was zu tun ist, auf Parameterwerten basiert. In der OOP-Welt würden wir die Funktion nur überladen, aber wenn dies nicht möglich ist, werden Sie eine Reihe von Flags übergeben (oder eine Reihe von Werten, und ob sie übergeben werden oder nicht, ist das Flag).

Ich denke, es ist bis zu einem gewissen Grad besser lesbar. Aber wie andere bereits erwähnt haben, ist es ein Code-Geruch, viele Parameter zu haben. Daher sehe ich in einer objektorientierten Sprache wie C # keine große Verwendung dafür.