Domanda

Ho questi due pezzi di codice, quale è più leggibile?

  1. foreach

    decimal technicalPremium = 0;
    foreach (Risk risk in risks)
    {
         technicalPremium = technicalPremium + risk.TechnicalPremium;
    }
    return technicalPremium;
    
  2. LINQ

    return risks.Sum(risk => risk.TechnicalPremium);
    
È stato utile?

Soluzione

Se il team che lavora sul codice sa cosa fa la versione di Linq e ne conosce il funzionamento interno, allora è più leggibile.

Altri suggerimenti

Usa quello che preferisci ma nascondilo in un metodo:

return risks.SumTechnicalPremium();

Nessuno dei due. Il primo è più dettagliato e può essere compreso da tutti. Il secondo è più conciso e facilmente comprensibile da tutti con una conoscenza passante di linq.

Direi che puoi basare la tua scelta sull'ambiente in cui ti trovi.

Per qualcuno che sa leggere LINQ, quello LINQ.

Per qualcuno che deve interpretare il codice passo dopo passo (usando intellisense / documentazione il più breve.

Vai con linq. Se pensi che abbia bisogno di spiegazioni, ci penserà un commento di una riga. Man mano che le persone si abituano maggiormente a linq, la necessità di commenti sparirà.

Il codice LINQ è sia molto leggibile che autocompensante.

La prima opzione è più leggibile per una più ampia gamma di persone. La seconda opzione ha una "barriera d'ingresso" in quanto il lettore potrebbe o potrebbe conoscere e comprendere LINQ. È più conciso e potrebbe quindi essere migliore se il tuo pubblico supera quella barriera d'ingresso.

Penso che la seconda opzione sia migliore in quanto dovrebbe essere più efficiente. Tuttavia, è meno ovvio ciò che sta accadendo (almeno per me).

Direi il primo poiché non conosco linq. A rischio di documentare eccessivamente userei quello con una breve descrizione di ciò che sta succedendo. Oppure dì semplicemente che è linq per le persone che potrebbero non averne idea.

Se fornisci un commento che spiega il suo scopo, sceglierei l'opzione Linq.

Il primo se non si ha conoscenza di Linq. Chiunque sviluppatore può leggere e comprendere il primo.

Non ci sono problemi di leggibilità qui. Fai clic su Somma e premi F1.

Linq per la vittoria.

Ogni lingua ha convenzioni per il modo migliore per codificare tali cose, quindi ciò che è più leggibile per le persone che usano regolarmente quella lingua non è universale. Per un programmatore Java o C # normale, la prima opzione è più leggibile. Per qualcuno abituato a LINQ o alla programmazione funzionale, il secondo è più leggibile.

Non conosco c #, ma la seconda alternativa mi sembra molto più pulita e potrei capire cosa fa (ok, con qualche ipotesi e controllo incrociato con la prima versione). Probabilmente a causa di un background funzionale. Ma nel primo devi cercare TechnicalPremium in 4 (!) Posizioni. Il secondo è molto più breve e più facile da capire se stai solo leggendo il codice.

o

decimal technicalPremium = 0;

foreach (Rischio in rischi) technicalPremium = technicalPremium + risk.TechnicalPremium;

return technicalPremium;

Vedo persone che dicono che gli piace il primo "se non conosci Linq". Sì, e il primo è illeggibile se non conosci C #. Questa non è una domanda di "che è più leggibile", ma di "quali funzioni linguistiche ci sentiamo a nostro agio nell'utilizzare?" & Quot;

Inizia conversando con il tuo team sulle parti della lingua / framework / set di strumenti che tutti odiano e dichiarale off limits. Tutto il resto è considerato parte del vocabolario standard e tutti dovrebbero essere fluenti. Questo elenco dovrebbe andare nel tuo documento sugli standard di codifica, proprio accanto a " non creare mai tipi di valori mutabili " e " non preoccuparti delle proprietà banali per i non pubblici membri ".

Finché Linq non è nel tuo " escludi " elenco, il secondo esempio è lontano più leggibile del primo. Perché? Perché dichiara l'intento del codice, invece di presentare semplicemente il meccanismo che il lettore deve decifrare.

Se il tuo obiettivo è renderlo più leggibile per " chiunque " che potrebbe venire dopo di te, quindi utilizzare la foreach. Interpreto "più leggibile" per indicare che chiunque abbia esperienza nelle basi della lingua dovrebbe essere in grado di cogliere. Per qualcuno che non ha familiarità con Linq e che utilizza ancora VS2005 o precedenti, la sintassi di Linq sarebbe confusa.

Direi che il primo pezzo di codice è sicuramente più leggibile e sarebbe ancora più leggibile se rinominassi almeno il rischio variabile in modo che avesse un nome diverso dalla classe. Probabilmente sarebbe anche meglio se rinominassi i rischi dell'array.

Sono d'accordo con coloro che sostengono che il secondo sarà facilmente comprensibile man mano che Linq diventerà più ampiamente adottato. È certamente più conciso.

Tuttavia, ho qualche preoccupazione per la facilità di debug. Sembra molto più semplice scorrere il codice nella foreach, per vedere esattamente cosa sta facendo in ogni passaggio.

Penso che dipenda da cosa intendi per "leggibile". Il primo esempio indica chiaramente la logica del programma e dovrebbe essere comprensibile a chiunque abbia un background di programmazione.

Per me, il secondo esempio è più intuitivo in base al contesto (ovvero, stai prendendo un array (o qualche altro tipo di raccolta) ed eseguendo un metodo chiamato Sum su ciascun elemento di tale array). L'unico posto in cui il secondo esempio può diventare meno chiaro è nell'espressione lambda vera e propria in particolare per qualcuno che non ha avuto esperienza con lambda o alraedy ha un background nella programmazione funzionale.

Penso che quando i lambda diventeranno più diffusi nella programmazione .NET, questo diventerà meno un problema. Allo stato attuale, penso che ci sia una curva di apprendimento molto piccola per comprendere le basi di come usare le espressioni lambda in .NET.

Il secondo, sicuramente. Avere un blocco di codice così grande per fare qualcosa di semplice come la somma è semplicemente superfluo. Inoltre non so cosa sia LINQ, ma è perfettamente leggibile per me.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top