Perché rimuovere le direttive inutilizzate in C #?

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

  •  08-07-2019
  •  | 
  •  

Domanda

Mi chiedo se ci sono ragioni (oltre a riordinare il codice sorgente) per cui gli sviluppatori usano il " Rimuovi Usused " funzionalità in Visual Studio 2008?

È stato utile?

Soluzione

Ci sono alcuni motivi per cui vorresti eliminarli.

  • È inutile. Non aggiungono alcun valore.
  • È confuso. Cosa viene utilizzato da quello spazio dei nomi?
  • In caso contrario, accumulerai gradualmente inutili utilizzando man mano che il codice cambia nel tempo.
  • L'analisi statica è più lenta.
  • La compilazione del codice è più lenta.

D'altra parte, non ci sono molti motivi per lasciarli dentro. Suppongo che ti risparmi lo sforzo di doverli eliminare. Ma se sei così pigro, hai problemi più grandi!

Altri suggerimenti

Direi piuttosto il contrario: è estremamente utile rimuovere istruzioni non necessarie e non necessarie.

Immagina di dover tornare al tuo codice tra 3, 6, 9 mesi - o qualcun altro deve prendere il tuo codice e mantenerlo.

Se hai una lunga lista lunga di istruzioni sull'utilizzo che non sono realmente necessarie, guardare il codice potrebbe essere abbastanza confuso. Perché lo usa lì dentro, se non viene usato nulla da quello spazio dei nomi ??

Immagino che in termini di manutenibilità a lungo termine in un ambiente professionale, suggerirei vivamente di mantenere il codice il più pulito possibile, e ciò include lo scarico di materiale non necessario da esso. Meno disordine equivale a meno confusione e quindi a maggiore manutenibilità.

Marc

Questa mi sembra una domanda molto sensata, che viene trattata in modo piuttosto irriverente dalle persone che rispondono.

Direi che qualsiasi modifica al codice sorgente deve essere giustificata. Queste modifiche possono avere costi nascosti e la persona che pone la domanda ha voluto esserne informata. Non hanno chiesto di essere chiamati "pigri", come una persona inimitata.

Ho appena iniziato a utilizzare Resharper e sta iniziando a dare avvertimenti e suggerimenti di stile sul progetto di cui sono responsabile. Tra questi vi è la rimozione di direttiva ridondante, ma anche qualificazioni ridondanti, capitalizzazione e molti altri. Il mio istinto è quello di riordinare il codice e risolvere tutti i suggerimenti, ma il mio responsabile commerciale mi mette in guardia contro cambiamenti ingiustificati.

Utilizziamo un processo di compilazione automatizzato e pertanto qualsiasi modifica al nostro repository SVN genererebbe cambiamenti che non potremmo collegare a progetti / bug / problemi e attiverebbe build e rilasci automatizzati che non fornivano alcuna modifica funzionale alle versioni precedenti.

Se guardiamo alla rimozione di qualificatori ridondanti, ciò potrebbe causare confusione agli sviluppatori poiché le classi dei nostri livelli Dominio e Dati sono differenziate solo dai qualificatori.

Se guardo all'uso corretto della capitalizzazione degli anacronimi (cioè ABCD - > Abcd), allora devo tenere conto del fatto che Resharper non esegue il refactoring di nessuno dei file Xml, usiamo i nomi delle classi di riferimento.

Quindi, seguire questi suggerimenti non è così semplice come sembra e dovrebbe essere trattato con rispetto.

Meno opzioni nel popup Intellisense (in particolare se gli spazi dei nomi contengono molti metodi di estensione).

Teoricamente Intellisense dovrebbe essere anche più veloce.

Oltre ai motivi già indicati, previene inutili conflitti di denominazione. Considera questo file: 

using System.IO;
using System.Windows.Shapes;

namespace LicenseTester
{
    public static class Example
    {
        private static string temporaryPath = Path.GetTempFileName();
    }
}

Questo codice non viene compilato perché entrambi gli spazi dei nomi System.IO e System.Windows.Shapes contengono ciascuno una classe denominata Path. Potremmo risolverlo usando il percorso completo della classe, 

        private static string temporaryPath = System.IO.Path.GetTempFileName();

o potremmo semplicemente rimuovere la riga usando System.Windows.Shapes; .

Rimuovili. Meno codice da guardare e stupirsi consente di risparmiare tempo e confusione. Vorrei che più persone TENGONO COSE SEMPLICI, NEAT e ORDINATE. È come avere camicie e pantaloni sporchi nella tua stanza. È brutto e devi chiederti perché è lì.

Aiuta anche a prevenire false dipendenze circolari, supponendo che tu sia anche in grado di rimuovere alcuni riferimenti dll / project dal tuo progetto dopo aver rimosso gli utilizzi non utilizzati.

La compilazione del codice è più rapida.

Almeno in teoria, se ti venisse dato un file C # .cs (o qualsiasi singolo file di codice sorgente del programma), dovresti essere in grado di guardare il codice e creare un ambiente che simuli tutto ciò di cui ha bisogno. Con alcune tecniche di compilazione / analisi puoi persino creare uno strumento per farlo automaticamente. Se ciò viene fatto almeno da te, puoi assicurarti di comprendere tutto ciò che dice il file di codice.

Ora considera, se ti è stato dato un file .cs con 1000 usando direttive che solo 10 sono state effettivamente utilizzate. Ogni volta che guardi un simbolo che è stato recentemente introdotto nel codice che fa riferimento al mondo esterno, dovrai passare attraverso quelle 1000 righe per capire di cosa si tratta. Questo ovviamente rallenta la procedura sopra descritta. Quindi, se puoi ridurli a 10, ti aiuterà!

A mio avviso, la direttiva C # using è molto debole, poiché non è possibile specificare un singolo simbolo generico senza perdere la genericità e non è possibile utilizzare utilizzando la direttiva alias per utilizzare metodi di estensione. Questo non è il caso in altre lingue come Java, Python e Haskell, in quelle lingue che puoi specificare (quasi) esattamente ciò che vuoi dal mondo esterno. Ma poi, suggerirò di usare usando quando possibile.

Recentemente ho avuto un altro motivo per cui eliminare le importazioni non utilizzate è molto utile e importante.

Immagina di avere due assiemi, in cui uno fa riferimento all'altro (per ora chiamiamo il primo A e il B di riferimento). Ora quando hai il codice in A che dipende da B tutto va bene. Tuttavia ad un certo punto del processo di sviluppo noti che in realtà non hai più bisogno di quel codice ma lasci la dichiarazione di utilizzo dov'era. Ora non hai solo un insignificante usando -directive ma anche un riferimento assembly a B che non viene usato da nessuna parte ma nella direttiva obsoleta. Questo in primo luogo aumenta il tempo necessario per la compilazione di A , poiché anche B deve essere caricato.

Quindi questo non è solo un problema di codice più pulito e più facile da leggere, ma anche di mantenere i riferimenti degli assiemi nel codice di produzione in cui non tutti quegli assiemi di riferimento anche esistono .

Alla fine, nel nostro esempio, abbiamo dovuto spedire insieme B e A, sebbene B non sia usato da nessuna parte in A ma nella sezione usando . Ciò influirà in modo significativo sulle prestazioni di runtime di A quando carica l'assembly.

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