Sto ottenendo due punti di vista contraddittori al riguardo. Qualche fonte dice che ci dovrebbero essere meno piccoli metodi per ridurre le chiamate al metodo, ma un'altra fonte dice che scrivere un metodo più breve è buono per lasciare che il JIT faccia l'ottimizzazione.C#, metodo di scrittura più lungo o metodo più breve?
Quindi, qual è il lato corretto?
Il sovraccarico di effettuare effettivamente la chiamata al metodo è irrilevantemente piccolo nella maggior parte dei casi. Non devi mai preoccuparti di questo a meno che non sia possibile identificare chiaramente un problema lungo la strada che richiede di rivisitare il problema (non lo farai).
È molto più importante che il codice sia semplice, leggibile, modulare, gestibile e modificabile. I metodi dovrebbero fare una cosa, una cosa sola e delegare le sotto-cose ad altre routine. Ciò significa che i tuoi metodi dovrebbero essere il più breve possibile, ma non più breve. Vedrete molti più vantaggi in termini di prestazioni avendo un codice che è meno incline a errori e bachi perché è semplice, piuttosto che cercare di superare in astuzia il compilatore o il runtime.
La fonte che dice che i metodi dovrebbero essere lunghi è errata, su più livelli.
Nessuno, è necessario disporre di un metodo relativamente breve per ottenere la leggibilità .
Non esiste una semplice regola sulle dimensioni della funzione. La linea guida dovrebbe essere una funzione dovrebbe fare 'una cosa'. È un po 'vago, ma diventa più facile con l'esperienza. Le piccole funzioni generalmente portano alla leggibilità. I più grandi sono occasionalmente necessari.
Preoccuparsi per il sovraccarico delle chiamate al metodo è l'ottimizzazione prematura.
Come sempre, si tratta di trovare un buon equilibrio. La cosa più importante è che il metodo fa solo una cosa,. I metodi più lunghi tendono a fare più di una cosa.
Prima di tutto, non si dovrebbe assolutamente micro ottimizzare le prestazioni a livello di numero di metodi. Molto probabilmente non otterrai alcun beneficio misurabile in termini di prestazioni. Solo se hai qualche metodo che viene chiamato in un ciclo chiuso milioni di volte, potrebbe essere un'idea - ma non iniziare a ottimizzarlo prima di averne bisogno.
Si dovrebbe attenersi a metodi concisi e concisi, che fa una cosa, che rende chiaro l'intento del metodo. Questo ti darà un codice più facile da leggere, che è più facile da capire e promuove il riutilizzo del codice.
Il miglior criterio singolo per guidare l'utente nei metodi di dimensionamento è di mantenerli ben verificabili. Se è possibile (e in realtà FARE! -) testare accuratamente ogni singolo metodo, è probabile che il codice sia abbastanza buono; se si lesina sui test, è probabile che il codice sia, nel migliore dei casi, mediocre. Se un metodo è difficile da testare a fondo, allora è probabile che quel metodo sia "troppo grande" - cercando di fare troppe cose, e quindi anche più difficile da leggere e mantenere (oltre che mal testato e quindi un probabile rifugio per insetti).
Il costo più importante da considerare quando si scrive codice è la manutenzione. Spenderete molto, molto più più tempo a mantenere un'applicazione e a correggere i bug che mai risolverete i problemi di prestazioni.
In questo caso il costo quasi insignificante di chiamare un metodo è incredibilmente piccolo rispetto al costo di mantenere un metodo ingombrante e di grandi dimensioni. Piccoli metodi concisi sono più facili da mantenere e da comprendere. Inoltre, il costo di chiamare il metodo quasi certamente non avrà un impatto significativo sulle prestazioni della tua applicazione. E se lo fa, puoi solo accertarti che usando un profiler. Gli sviluppatori sono notoriamente pessimi nell'identificare i problemi di prestazioni in anticipo.
In generale, una volta identificato un problema di prestazioni, è facile risolverlo. Fare un metodo o, più importante, una base di codice, mantenibile è un costo molto più alto.
Personalmente, non ho paura dei lunghi metodi finché la persona che li scrive li scrive bene (ogni pezzo di sotto-task è separato da 2 newline e un bel commento precedente, ecc. Inoltre, l'identificazione è molto importante.). In effetti, molte volte li preferisco persino (ad esempio quando si scrive codice che fa le cose in un ordine specifico con logica sequenziale).
Inoltre, davvero non capisco perché rompere un metodo lungo in 100 pezzi migliorerà la leggibilità (come altri suggeriscono). Solo il contrario. Finirai per saltare da un capo all'altro e tieni alcuni pezzi di codice nella memoria solo per avere un quadro completo di ciò che sta accadendo nel tuo codice. Combina questo con la mancanza di commenti, nomi di funzioni errate, molti nomi di funzioni simili e hai la ricetta perfetta per il caos. Inoltre, si potrebbe andare dall'altra parte mentre si tenta di ridurre la dimensione dei metodi: per creare classi MANY e MOLTE funzioni ognuna delle quali può richiedere MOLTI parametri. Non penso che ciò migliori la leggibilità (specialmente per un mendicante di un progetto che non ha idea di cosa facciano ogni classe/metodo).
E la richiesta che "una funzione dovrebbe fare 'una cosa'" è molto soggettiva. 'Una cosa' potrebbe essere aumentare una variabile di uno fino a fare una tonnellata di lavoro presumibilmente per la 'stessa cosa'.
La mia regola è solo riutilizzabilità: Lo stesso codice non dovrebbe apparire molte volte in molti posti. Se questo è il caso, hai bisogno di una nuova funzione. Tutto il resto è solo un discorso filosofico. In una domanda di "perché rendi i tuoi metodi così grandi", rispondo, "perché non se il codice è semplice?".
(solo la mia opinione - voto basso quanto vuoi)