Qual è il modo migliore per impaginare una classe C #? [duplicare]

StackOverflow https://stackoverflow.com/questions/603758

  •  03-07-2019
  •  | 
  •  

Domanda

    

Questa domanda ha già una risposta qui:

         

Esiste un modo standard per creare un file C #? Come in, Campi, quindi Proprietà, quindi Costruttori, ecc.

Ecco cosa faccio normalmente, ma mi chiedo se esiste un modo standard?

  1. Classi o enumerazioni nidificate
  2. Campi
  3. Proprietà
  4. Eventi
  5. Costruttori
  6. Metodi pubblici
  7. Metodi privati ??

Le persone raggruppano i loro campi o li mettono con le proprietà? O le persone non si preoccupano di un ordine? Visual Studio sembra renderlo così difficile da fare.

Modifica : spostato qui un'altra parte di ReSharper: Fai in modo che Resharper rispetti le tue preferenze per l'ordine del codice.

È stato utile?

Soluzione

Tendo a utilizzare Microsoft StyleCop , che ha un ordine prestabilito secondo la regola SA1201 :

  

Causa Un elemento all'interno di un codice C #   il file non funziona in relazione a   gli altri elementi nel codice.

     

Descrizione regola Una violazione di questo   la regola si verifica quando gli elementi del codice   all'interno di un file non seguire uno standard   schema di ordinazione.

     

Per rispettare questa regola, elementi in   il livello radice del file o all'interno di a   lo spazio dei nomi deve essere posizionato in   ordine seguente:

     
      
  • Direttive Extern Alias ??
    •   
  • Uso delle direttive
    •   
  • I namespace
    •   
  • I delegati
    •   
  • Enums
    •   
  • Interfacce
    •   
  • Structs
    •   
  • Corsi
    •   
     

All'interno di una classe, struttura o interfaccia,   gli elementi devono essere posizionati in   ordine seguente:

     
      
  • Campi
    •   
  • Costruttori
    •   
  • Finalizzatori (distruttori)
    •   
  • I delegati
    •   
  • Eventi
    •   
  • Enums
    •   
  • Interfacce
    •   
  • Proprietà
    •   
  • indicizzatori
    •   
  • Metodi
    •   
  • Structs
    •   
  • Corsi
    •   
     

Rispetto di un ordine standard   schema basato sul tipo di elemento can   aumentare la leggibilità e   manutenibilità del file e   incoraggiare il riutilizzo del codice.

     

Quando si implementa un'interfaccia, lo è   a volte desiderabile raggruppare tutto   membri dell'interfaccia accanto a uno   un altro. Questo a volte richiederà   violando questa regola, se l'interfaccia   contiene elementi di diversi tipi.   Questo problema può essere risolto tramite   utilizzo di classi parziali.

     
      

  1. Aggiungi l'attributo parziale alla classe, se la classe non lo è già   parziale.

    2.   

  2. Aggiungi una seconda classe parziale con lo stesso nome. È possibile posizionare   questo nello stesso file, appena sotto il   classe originale o entro un secondo   file.

    3.   

  3. Sposta l'ereditarietà dell'interfaccia e tutti i membri dell'interfaccia   implementazione nella seconda parte di   la classe.

    4.   

Altri suggerimenti

Penso che non esista un modo migliore . Ci sono due cose importanti da considerare quando si tratta di layout. La prima cosa più importante è la coerenza. Scegli un approccio e assicurati che l'intero team sia d'accordo e applichi il layout. In secondo luogo, se la tua classe diventa abbastanza grande da cercare dove vivono quelle fastidiose proprietà (o devi implementare le regioni per renderle più facili da trovare), allora la tua classe è probabilmente troppo grande. Valuta di annusarlo e di effettuare il refactoring in base a ciò che senti.

Per rispondere alla domanda reshaper, seleziona Digita layout membri in Opzioni (sotto il nodo C # ). Non è semplice, ma è possibile modificare l'ordine del layout.

Non credo che le regioni siano necessariamente un segno di codice errato. Ma per determinare che dovrai rivedere ciò che hai. Come ho affermato qui ecco come regionalizza il mio codice.


enumerazioni
dichiarazioni
Costruttori
metodi
Gestori di eventi
proprietà

Ma la cosa principale è mantenerlo coerente e propositivo.

Tendo a raggruppare i dati privati ??e tendo a raggruppare metodi / proprietà correlati in gruppi funzionali. 

public class Whatever {
   // private data here
   int _someVal = kSomeConstant;

   // constructor(s)
   public Whatever() { }

#region FabulousTrick  // sometimes regionize it
   // fabulous trick code
   private int SupportMethodOne() { }
   private double SupportMethodTwo() { }
   public void PerformFabulousTrick(Dog spot) {
       int herrings = SupportMethodOne();
       double pieces = SupportMethodTwo();
       // etc
   }
#endregion FabulousTrick
   // etc
}

Puoi provare Regionerate per aiutarti. Mi piace davvero ed è una scelta di Scott Hanselman.

Come detto, non penso che esista un modo migliore in quanto tale. Ma alcune organizzazioni ti aiutano il programmatore.

Quante volte in un lungo progetto hai passato del tempo a fare lo spasso di uno o più file sorgente cercando di trovare una delle tue funzioni.

Quindi uso molto il #region in questo modo -

  1. Eventi regione : tutti i riferimenti a eventi utilizzati da questa classe (almeno in questa particolare classe parziale).

  2. Controlli della regione : tutte le funzioni che interagiscono direttamente con i controlli di un modulo.

  3. MDI regione : imposta il mdi su

    Quindi ci sarà qualcosa a che fare con la funzionalità piuttosto che con l'interfaccia,

  4. Ricerche Regex regione

Faccio il trucco mentre procedo, ma usando lo stesso modello che uso sempre. Devo dire che mi è stato detto da alcuni programmatori che raccolgono il mio lavoro che è facile da seguire e altri che è disordinato.

Puoi compiacere metà delle persone metà del tempo e l'altra metà del quarto del tempo e l'altro quarto del tempo confondi tutti, incluso te stesso. Penso che lo abbia detto Winston Chrchil.

Qualunque cosa ti renda più produttivo. Ad alcuni piacciono i campi privati ??accanto agli accessi alle proprietà, ad altri campi simili sopra i costruttori. La cosa più importante che può aiutare è il raggruppamento di "like", " elementi. Personalmente mi piace riunire metodi privati, proprietà private, ecc.

Prova alcune cose ancora e ancora, qualunque cosa ritieni ti renda più produttivo e ti aiuti a mantenere il tuo codice.

Ciascuno per conto suo, ma tendo a seguire lo stesso ordine seguito dall'aiuto di MSDN.

Inoltre, non mi piace nidificare classi o enumerazioni, invece di creare file separati per loro, il che semplifica anche la scrittura di unit test (poiché è facile trovare il file di test associato quando è necessario aggiungere / correggere / refactor un test ).

IMHO l'ordine non è così importante perché VS rende molto facile trovare tutti i membri (specialmente se segui l'approccio di una classe / interfaccia / enum per file) e Sandcastle li raggrupperà se vuoi creare documenti, quindi sarei più preoccupato di dare loro nomi significativi.

Oltre a mantenere un insieme coerente di regioni nei file di classe, mantengo tutti i componenti di una regione in ordine alfabetico. Tendo ad avere un po 'di "memoria visiva" quando si tratta di leggere il codice e mi fa impazzire dover usare il menu a discesa di navigazione per trovare il codice in un file perché è ovunque.

Uso il seguente layout:

eventi campi globali / di classe privato / interno    proprietà    metodi pubblico / protetto    proprietà    metodi classi nidificate (anche se cerco di evitarle quando possibile)

Credo fermamente anche in 1 codice "cosa". (classe, interfaccia o enum) per file, con il nome del file uguale a " cosa " nome. Sì, rende un progetto più ampio ma rende infinitamente più facile trovare le cose.

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