Identifica questo stile di programmazione

Question

Identifica questo stile di programmazione

#1 da (10 voti)
#2 da (4 voti)
#3 da (3 voti)
#4 da (2 voti)

4

Alcuni dei codici legacy che ho ereditato utilizzano il fatto che C # supporta più assegnazioni per scrivere codice come:

void DisableControls()
{
    ddlStore.Enabled                =
    ddlProgram.Enabled              =
    ddlCat.Enabled                  =
    btnSaveProxy.Enabled            =
    btnCancelProxy.Enabled          =
    btnViewMassManagerProxy.Enabled =
    grdPromo.Enabled                = false;
}

È uno stile molto carino , con tutte le = allineate in modo ordinato e il valore assegnato in basso, ma è anche piuttosto noioso con cui lavorare. (E sì, quelle sono schede che allineano le cose, non spazi).

Mi piacerebbe sapere cosa, se non altro, questo stile implica il codificatore originale, poiché l'ho visto solo in alcune occasioni prima. Indica uno sfondo C ++? .NET 1.1? Solo le preferenze personali di qualcuno?

~~C'è qualche ragione per cui l'assegnazione concatenata come questa sarebbe più efficiente dell'impostazione individuale di .Enabled di ogni controllo? Meno così?~~ (Questa parte ha ricevuto risposta dal commento di @ gnat: This way makes it easy to insert btnWhatever.Enabled = as new buttons are added and delete as some buttons are deleted )

Modifica: altri elementi dello stile di questa persona, supponendo che l'intero file sia stato scritto da una sola persona (probabile ma non certo), include l'inserimento di argomenti di funzione nella riga successiva e l'inserimento di virgole all'inizio di una riga anziché la fine della riga precedente. Esempio:

PromoUpdate[] GetPromoUpdates(
                            StateField field)
{
    List<PromoUpdate> updates   = new List<PromoUpdate>();
    foreach (PromoOptInState p in field.States.Where(
                                                    x => x.IsDirty))
    {
        updates.Add(new PromoUpdate() {
            promoCode   = p.Code 
            , optIn     = p.IsOptedIn
        });
    }
    return updates.ToArray();
}

È molto strano.

coding-style code-formatting c#

posta Bobson 12.05.2014 - 21:40

fonte

4 risposte

Leggi altre domande sui tag coding-style code-formatting c#

Scegliere tra progetti singoli o multipli in un repository git? In che modo std :: string in c ++ alloca la memoria? [chiuso]

score 10 · Answer 1

/*********************************************************************
 * People who do indent that way also tend to write pretty comments. *
 * It looks so very pretty, so very professional. Except it's not.   *
 *********************************************************************/

Supponiamo che una variabile debba essere rinominata per qualche motivo. Quel semplice cambiamento potrebbe significare molti cambiamenti superflui perché l'autore originale cedette allo stile di programmazione del "bel codice". Come manutentore, devi controllare l'intero codice del codice per vedere se hai infranto la bellezza del codice.

Supponiamo che il bel commento sia sbagliato. Non descrive il motivo per cui esiste il codice o cosa fa il codice. È carino, ma sbagliato. Forse l'autore originale ha ripensato il design ma non ha modificato il bel commento. Forse qualche programmatore di manutenzione precedente ha corretto un errore ma non ha corretto il bel commento. Forse è successo più e più volte.

C'è una grande differenza tra codice bello e codice troppo bello. Il bel codice non ha bisogno di tonnellate di trucco.

Aggiorna

Quel codice allineato sui segni di uguale certamente sembra più carino, ed è forse più facile da leggere, in particolare quando gli obiettivi sul lato sinistro hanno solo lunghezze leggermente dissimili. Questo allineamento serve anche come una forma di codice di auto-documentazione per mostrare che quel blocco di istruzioni di assegnazione è in qualche modo correlato l'uno con l'altro. Per questi motivi, Steve McConnell ha sostenuto l'allineamento dei segni di uguale in un blocco di istruzioni di assegnazione nella prima edizione di Codice completo .

Tuttavia, ha ritirato questa raccomandazione nelle edizioni successive. Invece ha esplicitamente ammonito contro questo stile:

Do not align right sides of assignment statements.

Il suo fondamento logico per invertire completamente la sua raccomandazione a questo proposito è stato che l'enorme costo di manutenzione associato a questo stile non giustifica quel leggero aumento di leggibilità e comprensibilità.

Riguardo allo stile virgola-primo, l'ho visto e non mi piace. Lo metto nella stessa classe delle condizioni di yoda ( if (42 == foo) do_something(); e if ("foobar".equals(baz)) do_something_else(); ). Per me, sia le condizioni virgola-prima che quelle yoda sono troppo sconvolgenti per il modo in cui normalmente leggo e penso.

Tutto questo è ovviamente un problema religioso di programmazione. Alcune persone adorano le loro dichiarazioni di assegnazione formattate a blocchi, altre amano lo stile virgola-prima, mentre altre amano le loro condizioni di yoda. La mia regola: quando mantengo il codice di qualcun altro, dovrei adattarmi meglio allo stile di quell'autore. Nuovo codice? Se il progetto dà un certo margine di manovra, scriverò quel nuovo codice nel mio stile preferito.

score 4 · Answer 2

Mettere le virgole all'inizio di una riga piuttosto che alla fine della precedente è comune in SQL, quindi forse uno sfondo di database?

Ti aiuta a commentare le sezioni che non vuoi più facilmente, anche se è l'ultimo elemento nell'elenco che stai commentando.

SELECT Name
       , Address
       -- , Email
FROM Customers
WHERE Address IS NOT NULL
  -- AND Email IS NOT NULL

(nota le righe commentate relative all'email)

Sì, potresti obiettare che commentare la prima riga dell'elenco ora ha un'incoerenza, ma sembra che sia un problema minore.

score 3 · Answer 3

Io uscirò su un ramo e dirò Haskell, di tutte le cose.

Dai un'occhiata alla guida di stile di Johan Tibell qui , o il codice mostra qui . Vedrai alcune delle stesse funzioni, come indentazione profonda su nuove righe o virgole che precedono gli elementi della lista.

Sto lavorando a un progetto che ha una buona dose di persone con lo sfondo Haskell e non è difficile trovare uno stile simile.

Ho convenuto che sembra strano in un linguaggio 'bretelle'.

score 2 · Answer 4

Questo è uno stile un po 'unico. Ho visto un allineamento piuttosto frequente degli operatori di assegnazione in C, ma non in modo concatenato. Quindi vedresti qualcosa di simile:

int foo    = 1;
int bar    = 2;
int bazbiz = 3;

Con l'idea di richiamare tutti i compiti in un blocco e renderlo esplicitamente chiaro "questo è il posto dove sto assegnando le cose".

Alcuni sostengono che sia migliorata la leggibilità se il compilatore non fornisce valori predefiniti per le variabili.

Usarlo con compiti concatenati sembra un po 'più insolito. La maggior parte dei casi che ho visto sembravano:

int foo = bar = bazbiz = 0;