Pourquoi supprimer les directives using inutilisées en C #?

Je me demande s'il y a des raisons (en dehors de la mise en ordre du code source) pour lesquelles les développeurs utilisent la fonctionnalité «Supprimer les inutilisés Usings» dans Visual Studio 2008?

Il y a plusieurs raisons pour lesquelles vous voudriez les supprimer.

• C'est inutile. Ils n'ajoutent aucune valeur.
• C'est confu. Qu'est-ce qui est utilisé à partir de cet espace de noms?
• Si vous ne le faites pas, vous accumulerez progressivement des usinginstructions inutiles à mesure que votre code évoluera au fil du temps.
• L'analyse statique est plus lente.
• La compilation du code est plus lente.

D'un autre côté, il n'y a pas beaucoup de raisons de les laisser. Je suppose que vous vous évitez de devoir les supprimer. Mais si vous êtes aussi paresseux, vous avez de plus gros problèmes!

Je dirais bien au contraire - il est extrêmement utile de supprimer les instructions d'utilisation inutiles et inutiles.

Imaginez que vous deviez revenir à votre code dans 3, 6, 9 mois - ou quelqu'un d'autre doit reprendre votre code et le maintenir.

Si vous avez une longue liste d'instructions using qui ne sont pas vraiment nécessaires, regarder le code peut être assez déroutant. Pourquoi est-ce utilisé là-dedans, si rien n'est utilisé à partir de cet espace de noms?

Je suppose qu'en termes de maintenabilité à long terme dans un environnement professionnel, je suggérerais fortement de garder votre code aussi propre que possible - et cela inclut de vider des éléments inutiles. Moins d'encombrement signifie moins de confusion et donc une meilleure maintenabilité.

Marc

Cela me semble être une question très sensée, qui est traitée de manière assez désinvolte par les personnes qui y répondent.

Je dirais que toute modification du code source doit être justifiée. Ces changements peuvent avoir des coûts cachés et la personne qui pose la question a voulu en être informée. Ils n'ont pas demandé à être qualifiés de "paresseux", comme une personne inimitée.

Je viens de commencer à utiliser Resharper, et il commence à donner des avertissements et des conseils de style sur le projet dont je suis responsable. Parmi eux, il y a la suppression des directives utilisant redondantes, mais aussi des qualificatifs redondants, la capitalisation et bien d'autres. Mon instinct est de ranger le code et de résoudre tous les indices, mais mon chef d'entreprise me met en garde contre les changements injustifiés.

Nous utilisons un processus de construction automatisé, et par conséquent, toute modification de notre référentiel SVN générerait des changements que nous ne pourrions pas lier à des projets / bogues / problèmes, et déclencherait des versions et des versions automatisées qui n'apportaient aucun changement fonctionnel aux versions précédentes.

Si nous examinons la suppression des qualificatifs redondants, cela pourrait éventuellement semer la confusion chez les développeurs car les classes de nos couches Domaine et Données ne sont différenciées que par les qualificatifs.

Si je regarde la bonne utilisation de la capitalisation des anachronymes (c'est-à-dire ABCD -> Abcd), je dois prendre en compte que Resharper ne refactorise aucun des fichiers Xml que nous utilisons ces noms de classe de référence.

Donc, suivre ces conseils n'est pas aussi simple qu'il y paraît, et doit être traité avec respect.

En plus des raisons déjà données, il évite les conflits de noms inutiles. Considérez ce fichier:

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

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

Ce code ne se compile pas car les espaces de noms System.IO et System.Windows.Shapes contiennent chacun une classe appelée Path. Nous pourrions le réparer en utilisant le chemin complet de la classe,

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

ou nous pourrions simplement supprimer la ligne using System.Windows.Shapes;.

Moins d'options dans la fenêtre contextuelle Intellisense (en particulier si les espaces de noms contiennent de nombreuses méthodes d'extension).

En théorie, Intellisense devrait également être plus rapide.

Retirez-les. Moins de code à regarder et à s'interroger économise du temps et de la confusion. Je souhaite que plus de gens gardent les choses simples, propres et ordonnées. C'est comme avoir des chemises et des pantalons sales dans votre chambre. C'est moche et il faut se demander pourquoi c'est là.

Cela permet également d'éviter les fausses dépendances circulaires, en supposant que vous puissiez également supprimer certaines références dll / projet de votre projet après avoir supprimé les utilisations inutilisées.

Le code se compile plus rapidement.

Récemment, j'ai eu une autre raison pour laquelle la suppression des importations inutilisées est très utile et importante.

Imaginez que vous ayez deux assemblys, où l'un référence l'autre (pour l'instant appelons le premier Aet le référencé B). Maintenant, quand vous avez du code dans A qui dépend de B, tout va bien. Cependant, à un certain stade de votre processus de développement, vous remarquez que vous n'avez plus besoin de ce code, mais vous laissez l'instruction using où elle se trouvait. Maintenant, vous avez non seulement une usingdirective vide de sens, mais aussi une référence d' assembly à Blaquelle n'est utilisée nulle part, mais dans la directive obsolète. Cela augmente tout d'abord le temps nécessaire à la compilation A, car il Bdoit également être chargé.

Il ne s'agit donc pas seulement d'un problème de code plus propre et plus facile à lire, mais également de gestion des références d'assembly dans le code de production où tous ces assemblys référencés n'existent même pas .

Enfin, dans notre exemple, nous avons dû expédier B et A ensemble, bien que B ne soit utilisé nulle part dans A mais dans la section using. Cela affectera massivement l' exécution -performance de Alors du chargement de l'ensemble.

Au moins en théorie, si vous avez reçu un fichier C # .cs (ou n'importe quel fichier de code source de programme unique), vous devriez être en mesure de regarder le code et de créer un environnement qui simule tout ce dont il a besoin. Avec une technique de compilation / analyse, vous pouvez même créer un outil pour le faire automatiquement. Si cela est fait par vous au moins à l'esprit, vous pouvez vous assurer de comprendre tout ce que dit le fichier de code.

Considérez maintenant, si vous avez reçu un fichier .cs avec 1000 usingdirectives dont seulement 10 ont été réellement utilisées. Chaque fois que vous regardez un symbole nouvellement introduit dans le code qui fait référence au monde extérieur, vous devrez parcourir ces 1000 lignes pour comprendre de quoi il s'agit. Cela ralentit évidemment la procédure ci-dessus. Donc, si vous pouvez les réduire à 10, cela vous aidera!

À mon avis, la usingdirective C # est très très faible, car vous ne pouvez pas spécifier un seul symbole générique sans perdre la généricité, et vous ne pouvez pas utiliser la usingdirective alias pour utiliser des méthodes d'extension. Ce n'est pas le cas dans d'autres langages comme Java, Python et Haskell, dans ces langages vous pouvez spécifier (presque) exactement ce que vous voulez du monde extérieur. Mais événement alors, je suggérerai d'utiliser l' usingalias chaque fois que possible.