Pourquoi supprimer les directives using inutilisées en C #?
Je me demande s'il y a des raisons (en dehors du nettoyage du code source) pour lesquelles les développeurs utilisent la fonctionnalité "Supprimer les Usings" non utilisés dans Visual Studio 2008?
Il y a plusieurs raisons pour lesquelles vous voudriez les retirer.
- 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 instructions
usinginutiles à mesure que votre code change avec le 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 épargnez l'effort d'avoir à les supprimer. Mais si vous êtes si paresseux, vous avez de plus gros problèmes!
Je dirais tout à fait le contraire - il est extrêmement utile de supprimer les déclarations d'utilisation inutiles et inutiles.
Imaginez que vous deviez revenir à votre code dans 3, 6, 9 mois - ou que quelqu'un d'autre doive reprendre votre code et le maintenir.
Si vous avez une longue liste de tâches à utiliser qui ne sont pas vraiment nécessaires, regarder le code peut être assez déroutant. Pourquoi utilise-t-on 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ère fortement de garder votre code aussi propre que possible - et cela inclut le vidage de choses inutiles. Moins d'encombrement équivaut à moins de confusion et donc à une plus grande maintenabilité.
Marc
Cela me semble être une question très sensible, 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 traités de "paresseux", comme une personne l'a intimidé.
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, la suppression des directives redondantes à l'aide, 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 donc toute modification de notre référentiel SVN générerait des modifications que nous ne pourrions pas lier à des projets/bogues/problèmes, et déclencherait des versions et des versions automatisées qui n'ont apporté aucun changement fonctionnel aux versions précédentes.
Si nous examinons la suppression des qualificatifs redondants, cela pourrait éventuellement causer de la confusion aux développeurs, car les classes de nos couches de domaine et de données ne sont différenciées que par les qualificatifs.
Si je regarde l'utilisation correcte 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 pour les 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.
Moins d'options dans la fenêtre contextuelle Intellisense (en particulier si les espaces de noms contiennent de nombreuses méthodes d'extension).
Théoriquement, Intellisense devrait également être plus rapide.
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 compile pas car les espaces de noms System.IO et System.Windows.Shapes contiennent chacun une classe appelée Path. Nous pourrions le corriger en utilisant le chemin de classe complet,
private static string temporaryPath = System.IO.Path.GetTempFileName();
ou nous pourrions simplement supprimer la ligne using System.Windows.Shapes;.
Retirez-les. Moins de code à regarder et à se poser permet d'économiser du temps et de la confusion. Je souhaite que plus de gens GÉRENT LES CHOSES SIMPLES, NEAT et TIDY. C'est comme avoir des chemises et des pantalons sales dans votre chambre. C'est moche et vous devez vous demander pourquoi c'est là.
Il permet également d'éviter les fausses dépendances circulaires, en supposant que vous pouvez également supprimer certaines références dll/project 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 assemblages, où l’un fait référence à l’autre (pour l’instant appelons le premier A et 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ù il se trouvait. Maintenant, vous avez non seulement une directive using- vide de sens mais aussi une Assembly-reference à B qui n'est utilisée nulle part ailleurs que dans la directive obsolète. Cela augmente d'abord le temps nécessaire à la compilation de A, car B doit également être chargé.
Donc, ce n'est pas seulement un problème de code plus propre et plus facile à lire, mais aussi de maintien des références d'assembly dans le code de production où tous ces assemblages référencés n'existent 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 le runtime - les performances de A lorsque chargera l'Assemblée.
Au moins en théorie, si vous avez reçu un fichier C # .cs (ou tout autre fichier de code source de programme), vous devriez pouvoir regarder le code et créer un environnement qui simule tout ce dont il a besoin. Avec certaines techniques 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 directives using dont 10 seulement 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. Ceci ralentit évidemment la procédure ci-dessus. Donc, si vous pouvez les réduire à 10, cela vous aidera!
À mon avis, la directive C # using est très très faible, car vous ne pouvez pas spécifier un seul symbole générique sans perte de généricité, et vous ne pouvez pas utiliser la directive alias using 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 êtes en mesure de spécifier (presque) exactement ce que vous voulez du monde extérieur. Mais alors, je vais suggérer d'utiliser l'alias using autant que possible.