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 tutti gli = allineati 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 è stata risolta 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 (probabilmente ma non certo), include l'inserimento di argomenti di funzione nella riga successiva e l'inserimento di virgole all'inizio di una riga anziché alla 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#

Invio del routing negli script PHP o tramite il server Web (NGINX) Risoluzione delle classi di dati personalizzate con i modelli

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 "grazioso 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 ancora e ancora.

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 sicuramente sembra più carino, ed è forse più facile da leggere, in particolare quando gli obiettivi sul lato sinistro hanno solo lunghezze leggermente diverse. Questo allineamento serve anche come una sorta 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.

La sua logica per rovesciare completamente la sua raccomandazione a questo proposito è stata 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 sia 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 personale: 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 nell'elenco ora ha un'incoerenza, ma questo sembra essere 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;