Ich sehe Code mit vielen Funktionsargumenten in verschiedenen Projekten. Es gibt eine Geschichte, die Menschen höchstens sieben verstehen können. Bitte überlegen Sie, sie zu reduzieren. Der wichtigste Punkt ist, dass die Anzahl der Argumente selten zunimmt, wenn Sie über die Aufteilung der Verarbeitung nachdenken. Ich habe einen Mustermantel basierend auf einem tatsächlichen Beispiel geschrieben.
Ziehen Sie in Betracht, Daten aus acht Tabellen auf dem Bildschirm abzurufen und auf dem Bildschirm anzuzeigen.
void Main(int id)
{
//Erste Anzeigeverarbeitung des Bildschirms
var table1Rows = GetTable1Rows(id);
var table2Rows = GetTable2Rows(id);
var table3Rows = GetTable3Rows(id);
var table4Rows = GetTable4Rows(id);
var table5Rows = GetTable5Rows(id);
var table6Rows = GetTable6Rows(id);
var table7Rows = GetTable7Rows(id);
var table8Rows = GetTable8Rows(id);
InitializeView(
table1Rows,
table2Rows,
table3Rows,
table4Rows,
table5Rows,
table6Rows,
table7Rows,
table8Rows);
}
/**Erste Anzeigeverarbeitung**/
private void InitializeView(
List<Table1Row> table1Rows,
List<Table2Row> table2Rows,
List<Table3Row> table3Rows,
List<Table4Row> table4Rows,
List<Table5Row> table5Rows,
List<Table6Row> table6Rows,
List<Table7Row> table7Rows,
List<Table8Row> table8Rows)
{
//Auf den Bildschirm einstellen.
SetView(
table1Rows,
table2Rows,
table3Rows,
table4Rows,
table5Rows,
table6Rows,
table7Rows,
table8Rows);
}
/**Geheimnisvoller Ersetzungsprozess, der beim ersten Anzeigeprozess aufgerufen wurde**/
private void SetView(
List<Table1Row> table1Rows,
List<Table2Row> table2Rows,
List<Table3Row> table3Rows,
List<Table4Row> table4Rows,
List<Table5Row> table5Rows,
List<Table6Row> table6Rows,
List<Table7Row> table7Rows,
List<Table8Row> table8Rows)
{
SetTable1(table1Rows);
SetTable2(table2Rows);
SetTable3(table3Rows);
SetTable4(table4Rows);
SetTable5(table5Rows);
SetTable6(table6Rows);
SetTable7(table7Rows);
SetTable8(table8Rows);
}
/**Der Vorgang zum Einstellen jedes DTO auf dem Bildschirm. Der einzustellende Code selbst wird weggelassen.**/
private void SetTable1(List<Table1Row> table1Rows)
{
}
private void SetTable2(List<Table2Row> table2Rows)
{
}
private void SetTable3(List<Table3Row> table2Rows)
{
}
private void SetTable4(List<Table4Row> table2Rows)
{
}
private void SetTable5(List<Table5Row> table2Rows)
{
}
private void SetTable6(List<Table6Row> table2Rows)
{
}
private void SetTable7(List<Table7Row> table2Rows)
{
}
private void SetTable8(List<Table8Row> table2Rows)
{
}
/**Rückgabe einer leeren Instanz für das Beispiel,
*Eigentlich Tabelle 1,...,Dao existiert bis Tabelle 8 und wird von der DB erworben.
**/
private List<Table1Row> GetTable1Rows(int id)
{
return new List<Table1Row>();
}
private List<Table2Row> GetTable2Rows(int id)
{
return new List<Table2Row>();
}
private List<Table3Row> GetTable3Rows(int id)
{
return new List<Table3Row>();
}
private List<Table4Row> GetTable4Rows(int id)
{
return new List<Table4Row>();
}
private List<Table5Row> GetTable5Rows(int id)
{
return new List<Table5Row>();
}
private List<Table6Row> GetTable6Rows(int id)
{
return new List<Table6Row>();
}
private List<Table7Row> GetTable7Rows(int id)
{
return new List<Table7Row>();
}
private List<Table8Row> GetTable8Rows(int id)
{
return new List<Table8Row>();
}
/**
*Vereinfacht für ein Beispiel, aber tatsächlich ein komplexerer Satz von Tabellen.
*Ich denke hier nicht an schlechtes Tischdesign.
**/
public class Table1Row
{
int Id { get; set; }
string Value { get; set; }
}
public class Table2Row
{
int Id { get; set; }
string Value { get; set; }
}
public class Table3Row
{
int Id { get; set; }
string Value { get; set; }
}
public class Table4Row
{
int Id { get; set; }
string Value { get; set; }
}
public class Table5Row
{
int Id { get; set; }
string Value { get; set; }
}
public class Table6Row
{
int Id { get; set; }
string Value { get; set; }
}
public class Table7Row
{
int Id { get; set; }
string Value { get; set; }
}
public class Table8Row
{
int Id { get; set; }
string Value { get; set; }
}
Das erste, was zu zeichnen ist, ist, dass es zwei Funktionen mit acht Argumenten gibt, von denen eines einen unbekannten Existenzgrund hat. Ich vermute, dass ich wahrscheinlich einen aussagekräftigeren Funktionsnamen haben wollte. Es gibt nicht nur viele Argumente, sondern der unnötig lange Variablenbereich macht es schwierig zu verfolgen, wie die Argumente der SetTable-Funktion abgerufen werden. Übrigens wird diese Funktion im eigentlichen Code nicht anderswo aufgerufen.
Kürzen Sie einfach den variablen Bereich und es wird aktualisiert.
void Main(int id)
{
//Erste Anzeigeverarbeitung des Bildschirms
InitializeView(id);
}
/**Erste Anzeigeverarbeitung**/
private void InitializeView(int id)
{
var table1Rows = GetTable1Rows(id);
SetTable1(table1Rows);
var table2Rows = GetTable2Rows(id);
SetTable2(table2Rows);
var table3Rows = GetTable3Rows(id);
SetTable3(table3Rows);
var table4Rows = GetTable4Rows(id);
SetTable4(table4Rows);
var table5Rows = GetTable5Rows(id);
SetTable5(table5Rows);
var table6Rows = GetTable6Rows(id);
SetTable6(table6Rows);
var table7Rows = GetTable7Rows(id);
SetTable7(table7Rows);
var table8Rows = GetTable8Rows(id);
SetTable8(table8Rows);
}
Übrigens werde ich ein Beispiel mit einer kleinen Anzahl von Argumenten, aber einem Problem geben.
private List<Table1Row> _table1Rows = null;
private List<Table2Row> _table2Rows = null;
private List<Table3Row> _table3Rows = null;
private List<Table4Row> _table4Rows = null;
private List<Table5Row> _table5Rows = null;
private List<Table6Row> _table6Rows = null;
private List<Table7Row> _table7Rows = null;
private List<Table8Row> _table8Rows = null;
void Main(int id)
{
//Erste Anzeigeverarbeitung des Bildschirms
_table1Rows = GetTable1Rows(id);
_table2Rows = GetTable2Rows(id);
_table3Rows = GetTable3Rows(id);
_table4Rows = GetTable4Rows(id);
_table5Rows = GetTable5Rows(id);
_table6Rows = GetTable6Rows(id);
_table7Rows = GetTable7Rows(id);
_table8Rows = GetTable8Rows(id);
InitializeView();
}
/**Erste Anzeigeverarbeitung**/
private void InitializeView()
{
//Auf den Bildschirm einstellen.
SetView();
}
/**Geheimnisvoller Ersetzungsprozess, der beim ersten Anzeigeprozess aufgerufen wurde**/
private void SetView()
{
SetTable1(_table1Rows);
SetTable2(_table2Rows);
SetTable3(_table3Rows);
SetTable4(_table4Rows);
SetTable5(_table5Rows);
SetTable6(_table6Rows);
SetTable7(_table7Rows);
SetTable8(_table8Rows);
}
Es sieht erfrischend aus, aber die Fehlerrate ist viel höher. Das Problem ist, dass eine private Variable verwendet wird und es sehr schwer zu verstehen ist, wann diese Variable aktualisiert wurde. Im Beispiel ist es leicht zu verstehen, da es nur einen Zuweisungsort gibt. In den meisten Fällen tritt jedoch häufig ein Fehler auf, wenn die private Variable in einer anderen Ereignisverarbeitung aktualisiert wird.
Es ist möglich, das Argument durch Verkürzung des Geltungsbereichs zu verkürzen. Üben Sie es daher bitte. Wenn Sie viele Argumente haben, sollten Sie sich überlegen, wie Sie diese reduzieren können. Es ist jedoch auch nicht gut, private Variablen zu verwenden. Es gibt auch eine Methode zum Gruppieren der Argumente in einer Klasse. Es ist jedoch besser, dies nach Berücksichtigung des Variablenbereichs zu tun. In diesem Fall müssen Sie sie nicht einmal in einer Klasse zusammenstellen. Hinweis) Der eigentliche Code, aus dem die Probe stammt, funktioniert und stört die verantwortliche Person jedes Mal, wenn Nachforschungen erforderlich sind.
Vorheriger Artikel (Behandlung des Bool-Typs)
Nächster Artikel (Können wir Funktionsaufrufe und Bedingungen trennen?)
Recommended Posts