Questo è un concetto che ho imparato in Programmazione strutturata e che si applica ancora alla programmazione orientata agli oggetti. Ho visto molti "Spaghetti Object Oriented Code", con metodi che hanno un sacco di righe ...
Ecco le idee rapide su quando tagliare una singola funzione / metodo in più:
- Regola empirica di 25 righe
Se il codice ha più di 25 righe, perché la mente del programmatore ha difficoltà a capire di più di quelle informazioni.
Quando sei un "ciclo", con un obiettivo specifico, e quel codice è molto esteso. Per "loop", intendo "for", "foreach", "while", ecc. Un "for" con 3 righe di codice non può richiedere di essere messo in un metodo separato, ma un "for" con 35 righe di codice, significa spostarlo.
Esempio di origine (C #):
before_blah();
for (int k=0; k < list.Count; k++) {
for_blah_1(k)
...
for_blah_42(k)
}
after_blah();
Esempio dest. (C #):
before_blah();
this.iterateitems(); // <-- for goes there
after_blah();
- Regola condizionale o alternativa
Simile, va per "blocchi" condizionali / alternativi come "if", "swith", "case", se alcune opzioni sono troppo estese, faccio un singolo metodo per quella opzione. Ci sono volte in cui, per ogni opzione, realizzo anche un singolo metodo, anche se non così grande.
Esempio di origine (C #):
switch (option) {
case 0:
blah_0_0();
break;
case 1:
blah_1_0();
...
blah_53_0();
break;
} // switch
Esempio dest. (C #):
switch (option) {
case 0:
cancelItem();
break;
case 1:
printItem();
break;
} // switch
Per "funzionale", non significa "funzione", ma attività. Se hai 3 o più linee di codice consecutivo, che condividono un obiettivo comune, potresti voler fare un
metodo separato.
Esempio di origine (C #):
FileStream F = new FileStream();
F.Path = parameterPath;
F.Options = myOptions;
F.Reset();
do_something();
F.Close();
Esempio dest. (C #):
FileStream F = this.PrepareFileStream(parameterPath, myOptions);
do_something();
F.Close();
Naturalmente, alcune di queste linee guida sono più soggettive che logiche.
Solo i miei 2 centesimi ...