Quale convenzione di denominazione utilizzare per i parametri della funzione C #

Ci sono situazioni in cui un nome passato in Parametro verrà inserito in un nuovo tipo, ma il nome dell'oggetto Passato dovrebbe rimanere simile. Nel caso degli attributi di classe, possiamo usare questo operatore, ma per quanto riguarda la variabile locale nelle funzioni. Quale convenzione di codifica è ampiamente utilizzata.

esempio,

void MyFunc(BaseClass myPara)
{
  DerivedClass _mypara = (BaseClass)myPara;
}

o al contrario

void MyFunc(BaseClass _myPara)
{
  DerivedClass mypara = (BaseClass)_myPara;
}

o qualsiasi altro convenzionale

Il prefisso dei parametri o delle variabili locali con un trattino basso non è molto idiomatico in C #, non è molto facile da leggere e non è spesso usato (anche se è legale, quindi se lo desideri sei libero di farlo).

Il nome migliore per il parametro e la variabile è un nome descrittivo. Devi pensare perché stai cambiando il tipo, qual è la ragione del cast. Quindi dovresti riuscire a trovare 2 nomi diversi. Ad esempio se hai passato una "persona" e l'hai convertita in un "cliente", allora potresti usare persona e / o cliente nei nomi delle variabili forse.

Se davvero non riesci a pensare a 2 nomi diversi, allora userei "come" nel nome ( c'era qualche domanda su questo sito qualche giorno fa a riguardo ). Ad esempio, useresti "myParaAsDerived" per la variabile locale.

Se possibile, non lo userei, penserei intensamente al problema che stai risolvendo e quali nomi significativi potrebbero essere usati, ma se tutto il resto fallisce questo è abbastanza leggibile.

In primo luogo utilizzando

void MyFunc(BaseClass _myPara)
{
} 

È chiaramente sbagliato! Poiché molti standard di codifica c # usano un prefisso "_" su tutti i nomi di campo ! Il codice deve essere facilmente comprensibile da altri programmatori, quindi il codice non deve essere scritto in modo tale da indurre in errore molti programmatori C #.

Dati tutti i vantaggi di piccoli metodi, personalmente non vedo alcuna necessità di una convenzione di denominazione per separare le variabili locali dai parametri. Se i tuoi metodi hanno così tanti parametri e variabili locali che non puoi dire cosa sta succedendo senza una convenzione di denominazione, hai problemi più grandi. (Questo è ben trattato nel Clean Code Book , un libro Java ma l'ho ancora trovato di grande beneficio come programmatore C #)

Se vuoi prefissarli con qualcosa, allora dovresti usare p_per parametro: in generale immagino che probabilmente infastidiresti molte persone se lo facessi. MA essere coerente, non farlo in un unico posto solo perché hai bisogno di due nomi diversi per le variabili a cui vuoi dare lo stesso nome.

Una buona regola generale con denominazione variabile va come;

• Se hai un solo tipo di oggetto, chiamalo con la sua funzione:

  var builder = new PizzaBuilder();

• Se ne hai più di un nome in base alla loro funzione e specializzazione:

  var pizzaBuilder = new PizzaBuilder();
  var milkShakeBuilder = new MilkShakeBuilder();

Le convenzioni di denominazione in C # ti consentiranno di:

• Utilizzo di PascalCasing per metodi, proprietà pubbliche e nomi di classi
• Utilizzo di IPascalCasing (notare la I all'inizio) per i nomi delle interfacce
• Utilizzo di camelCasing per i parametri del metodo e le variabili locali
• Utilizzo di _underscoredCamelCasing per i campi privati ​​di tutta la classe

E per favore stai alla larga dalla notazione ungherese. È inutile e non aderisce alle convenzioni C #.

La sottolineatura nella denominazione delle variabili può essere in qualche modo superflua in quanto abbiamo la parola chiave "this" per fare riferimento alle variabili a livello di classe in particolare. Se desideri saperne di più sulle convenzioni di denominazione variabile dagli esperti, ti suggerirei di dare un'occhiata al famigerato documento chiamato "Ottinger's Rules for Variable and Class Naming" di Tim Ottinger, un articolo supportato dal mentore del codice pulito Robert C. Martin .

Ottinger afferma che il tuo codice deve rimanere il più umanamente leggibile possibile, come una prosa ben scritta, quindi ...

public void Function(string p_Parameter1, string p_Parameter2)

... sarebbe più leggibile come ...

public void Function(string parameter1, string parameter2)

... dove parametro1 e 2 sono nomi descrittivi per le variabili corrispondenti.

Ecco il link, vale sicuramente la pena dare un'occhiata: Link

Credo nel suffisso dei parametri: stringa s_, int i_, ecc

Credo anche che i nomi dei parm dovrebbero essere brevi e generici possibile.

Ora per i motivi:

• Nella funzione, non vuoi modificare il parametro in alcun modo, se hai bisogno di una versione modificata, crea una nuova variabile per attaccarlo. La denominazione di parms con un suffisso ti assicurerà che non li assegni se stai pagando Attenzione.
• Eccezioni a questa regola si verificano quando il parametro è ref o out. Anche se uso ancora il suffisso su quelli.
• Perché nomi generici brevi? Dovresti documentare la tua funzione in modo da sapere cosa è veramente s_ in senso descrittivo. Quindi, a prescindere da ciò, l'uso di generici brevi è utile quando si creano gruppi di funzioni simili o si ritaglia un corpo di funzione per il trasporto in un'altra funzione come punto di partenza per la modifica.
• Il vero vantaggio dei nomi generici è che non devi ricordare ciò che hai chiamato quel parametro nella maggior parte dei casi. Sai che stai ricevendo una stringa, quindi è s_, ecc. E non devi chiederti se è 'nome file' o era 'percorso file' o era 'percorso completo', è l'unica stringa quindi è 's_'.

Tutto ha dei compromessi e se usi o meno qualcosa dipenderà molto da come si adatta al tuo stile attuale.