Mehrere Möglichkeiten, die Anzahl der Parameter zu steuern

Ich habe kürzlich die Spezifikationen des Unternehmens geklärt, und unter ihnen war „Die Anzahl der Parameter einer Funktion sollte 4 nicht überschreiten“ etwas umstritten. Wenn die Aufgabe erledigt werden kann, ist dies an sich nicht besser umstritten, aber dies kann beim Programmieren zu Schwierigkeiten führen, und es gibt Debatten darüber, ob es sich lohnt. Ich denke, es lohnt sich, dies zu tun, um es den Leuten, die Funktionen verwenden, einfacher zu machen. Die Schwierigkeiten beim Programmieren liegen oft daran, dass wir mit einigen Methoden zum Reduzieren von Parametern nicht vertraut sind. Hier ein paar Zusammenfassungen als Referenz:

1. Verwenden Sie Strukturen, um Parameter zu kapseln

Beispiel: Benutzer hinzufügen

Ursprünglicher Funktionskörper: AddUser (String Benutzername, String Passwort, String Adresse, String Telefon, int Alter)

Refactor: Fügen Sie eine Benutzerklasse hinzu:

Klasse Benutzer
{
öffentlicher String UserName { get;
öffentliche Zeichenfolge Passwort { get;
öffentliche Zeichenfolge Adresse { get;
öffentliche Zeichenfolge Phone { set;
public int Age { get;
}

Ändern Sie AddUser in: AddUser(Benutzer Benutzer)

Probleme: Wenn die hinzugefügte Klasse nicht an anderer Stelle verwendet wird, haben wir oft das Gefühl, dass es sich nicht lohnt. Zu diesem Zeitpunkt können wir die Verwendung anonymer Klassen zum Kapseln von Parametern in Betracht ziehen.

2. Verwenden Sie Attribute, um Parameter zu ersetzen

Wenn die AddUser-Methode in 1 in der User-Klasse platziert wird, können die Benutzerparameter in der AddUser-Methode weggelassen werden. Manchmal können einige Attribute hinzugefügt werden, um die Anzahl der Parameter in einigen Methoden zu reduzieren. Beim objektorientierten Design sollten Objekte für sich selbst verantwortlich sein und die Verantwortlichkeiten sollten klar definiert sein. Der Grund dafür, dass eine Methode zu viele Parameter hat, kann darin liegen, dass die Methode an einer Stelle geschrieben ist, an der sie nicht existieren sollte. Das im GRASP-Prinzip erwähnte „Informationsexperten“-Modell kann in vielen Fällen die Anzahl der Parameter reduzieren.

Beispiel: Kontoübertragung

Ursprüngliche Funktion: Überweisung (Konto von, Konto nach, Dezimalgeld)

Refactoring:

Code
öffentliche Klasse TransferProcess
{
privates Konto von;
privates Konto an;
public TransferProcess(Konto von, Konto an)
{
this.From = von;
this.To = to;
}
öffentliche ungültige Überweisung (Dezimalgeld)
{
if (money<From.Money)
{
From.Money = From.Money - Geld;
To.Money = To.Money + Geld;
//Datenbank aktualisieren
}
anders
{
throw new Exception("Guthaben überschritten");
}
}
}
Hinweis: Das Informationsexpertenmuster ist das grundlegendste Prinzip des objektorientierten Designs. Wenn eine Klasse über alle Informationen verfügt, die zur Erfüllung einer bestimmten Verantwortung erforderlich sind, sollte diese Verantwortung dieser Klasse zur Implementierung zugewiesen werden . Zu diesem Zeitpunkt ist diese Klasse der Informationsexperte, der dieser Verantwortung entspricht.

3. Nutzen Sie private Funktionen

Wenn wir eine Funktion aufrufen, benötigen wir oft nicht viele interaktive Parameter, aber wenn wir Parameter bereitstellen, müssen wir alle Bedingungen bereitstellen. Zu diesem Zeitpunkt können wir die Funktionen klassifizieren, die komplexesten Funktionen als privat kapseln und verfügbar machen Rufen Sie diese komplexen Funktionen auf, um die Funktion zu vervollständigen. Werfen wir einen Blick auf die Implementierung der TextBox-Methode in mvc:

Code
öffentliche statische Zeichenfolge TextBox(this HtmlHelper htmlHelper, string name, object value, IDictionary<string, object> htmlAttributes) {
return InputHelper(htmlHelper, InputType.Text, name, value, (value == null) /* useViewData */, false /* isChecked */, true /* setId */, true /* isExplicitValue */, htmlAttributes);
}

privater statischer String InputHelper(this HtmlHelper htmlHelper, InputType inputType, string name, object value, bool useViewData, bool isChecked, bool setId, bool isExplicitValue, IDictionary<string, object> htmlAttributes) {
if (String.IsNullOrEmpty(name)) {
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
}

TagBuilder tagBuilder = new TagBuilder("input");
... ...

Um dem Aufrufer jedoch maximale Flexibilität zu bieten, können wir manchmal auch die komplexeste Funktionsüberladung offenlegen.

4. params-Schlüsselwort

Gibt an, dass bei variabler Anzahl von Parametern der Methodenparameter des Parameters verwendet wird.

Verwendung:

Code
static void Main(string[] args)
{
UseParams(1, 2, 3);
}
public static void UseParams(params int[] list)
{
for (int i = 0; i < list.Length; i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
}

Diese Methode reduziert nicht wirklich die Anzahl der Parameter, sondern vereinfacht nur den Funktionskörper.

5. Verwenden Sie anonyme Klassen, um Parameter zu kapseln

Vorbereitende Kenntnisse: Werfen wir zunächst einen Blick auf RouteValueDictionary

Code
static void Main(string[] args)
{
RouteValueDictionary r = new RouteValueDictionary(new { id=1,name="lfm"});
foreach (Var-Element in r)
{
Console.WriteLine("{0}:{1}", item.Key, item.Value);
}
//Console.WriteLine();
}

Ergebnis:

ID:1

Name:lfm

RouteValueDictionary kann die Attributnamen und Attributwerte von Instanzen im Wörterbuch speichern.

Viele Stellen in MVC verwenden diese Methode zum Übergeben von Parametern.

Beispiel: <%= Html.ActionLink("Details", "Details", new { id=item.id })%>

Im ActionLink-Methodenkörper wird RouteValueDictionary verwendet, um das anonyme Objekt zu zerlegen und es dann auf dem Link zusammenzusetzen.