ReSharper pour le développement C#¶

Guide pratique pour utiliser ReSharper dans un codebase C# avec Visual Studio. Les fonctions et raccourcis peuvent varier selon la version et le keymap sélectionné; la documentation JetBrains consultée indique la branche ReSharper 2026.2.[1][10]

Vue d'ensemble¶

ReSharper est une extension de productivité et d'analyse de code de JetBrains pour Visual Studio. Dans un projet C#, il ajoute de l'analyse statique en continu, des corrections rapides, de la navigation avancée, de la génération de code et des refactorings qui peuvent tenir compte de toute la solution.[1][2]

L'idée n'est pas de remplacer le compilateur ou les tests. ReSharper donne plutôt du feedback plus tôt dans l'éditeur et automatise une grande partie du travail répétitif : trouver les usages d'un symbole, renommer une classe sans casser les références, extraire une méthode, nettoyer le style ou repérer du code mort.

Fonctions principales, par importance pratique¶

Fonction	Description
Analyse de code en temps réel	Détecte erreurs potentielles, problèmes de style, redondances, code inutilisé et améliorations possibles avant la compilation.
Quick-fixes avec `Alt+Enter`	Propose une correction directement à l'endroit du problème : ajouter un `using`, corriger une syntaxe, simplifier du code ou appliquer une convention.
Refactorings sûrs	Renomme, déplace, extrait ou modifie des symboles en mettant à jour les usages dans la solution.
Navigation dans la solution	Permet d'aller rapidement vers un fichier, un type, un membre, une implémentation, une déclaration ou les usages d'un symbole.
Completion C# améliorée	Offre une complétion plus contextuelle, comprend les abréviations CamelHumps et peut importer automatiquement des namespaces.
Génération de code	Génère propriétés, constructeurs, overrides, implémentations d'interfaces, comparateurs et autres blocs répétitifs.
Code Cleanup	Applique un profil de formatage et de nettoyage à un fichier, un projet ou une solution.
Templates de code	Insère rapidement des structures C# courantes avec des templates live ou surround.
Hiérarchies et usages	Explore les classes de base, les classes dérivées, les implémentations, la hiérarchie d'appels et les dépendances.
Tests unitaires	Détecte les tests et fournit un runner intégré pour les exécuter et inspecter leurs résultats.
Analyse en CI	Permet d'utiliser `InspectCode` et `CleanupCode` en dehors de Visual Studio pour contrôler la qualité et uniformiser le code.

Le workflow de base¶

1. Partir de `Alt+Enter`¶

Place le curseur sur le code souligné, puis appuie sur Alt+Enter. ReSharper affiche les inspections disponibles et les actions qui peuvent être appliquées dans le contexte.[2][3]

Exemples d'actions fréquentes :

importer le namespace manquant;
remplacer une construction par une syntaxe C# plus moderne;
supprimer un using inutilisé;
convertir une propriété ou un champ;
simplifier une expression;
générer ou implémenter des membres;
désactiver ou modifier la sévérité d'une inspection.

Conseil: ne clique pas automatiquement sur toutes les suggestions. Lis l'effet de la correction et vérifie que le changement correspond aux conventions du projet.

2. Utiliser `Refactor This`¶

Place le curseur sur un symbole ou sélectionne un bloc, puis utilise Ctrl+Shift+R dans le keymap Visual Studio. ReSharper affiche les refactorings applicables à cet endroit.[4][7]

Les refactorings C# utiles au quotidien sont notamment :

Rename — renommer une classe, méthode, propriété ou variable et mettre à jour les références;
Change Signature — ajouter, supprimer, renommer ou réordonner des paramètres;
Extract Method — sortir une sélection dans une nouvelle méthode;
Extract Interface — créer une interface à partir d'une classe;
Move Type to Another File — déplacer un type dans son propre fichier;
Move Type to Another Namespace — déplacer un type en corrigeant les références;
Introduce Variable, Introduce Field et Introduce Parameter;
Inline Variable, Inline Method et Inline Field;
Safe Delete — vérifier les usages avant de supprimer un symbole;
Convert Property to Auto-Property ou autres conversions ciblées.

ReSharper analyse la portée du changement — souvent la solution complète — et affiche les conflits avant d'appliquer le refactoring.[4]

3. Nettoyer le code après une modification¶

Code Cleanup applique les règles de formatage, les styles syntaxiques et certaines corrections de redondance selon un profil. Le raccourci du keymap Visual Studio est Ctrl+E, C.[5][8][10]

Les profils intégrés les plus utiles sont :

Full Cleanup — applique l'ensemble des tâches de nettoyage disponibles, à l'exception de certaines tâches comme la mise à jour de l'en-tête de fichier;
Reformat Code — reformate le code sans appliquer tout le nettoyage;
profil personnalisé — recommandé pour adapter le nettoyage aux règles de l'équipe.

Commence avec un seul fichier ou une sélection. Avant de nettoyer un projet complet, regarde le diff Git : un cleanup global peut produire beaucoup de changements de formatage et rendre une revue de code pénible.

Analyse de code : quoi regarder¶

ReSharper analyse normalement le fichier ouvert pendant que tu travailles et affiche les problèmes selon leur niveau de sévérité. Il ajoute aussi une barre de marqueurs à droite de l'éditeur et permet de naviguer d'un problème au suivant.[2]

Les catégories les plus pertinentes en C# sont :

Catégorie	Exemples
Erreurs potentielles	Code qui ne compile pas, symbole introuvable, conversion invalide.
Code inutilisé	`using`, champs, membres ou paramètres qui ne servent plus.
Redondances	Conditions inutiles, conversions superflues, code qui peut être simplifié.
Style	Nommage, ordre des membres, modificateurs, `var`, accolades et formatage.
Design	Classes trop couplées, membres qui pourraient être déplacés ou rendus statiques.
Performance	Certaines allocations, recherches ou constructions qui peuvent être améliorées.

Pour une analyse plus large, utilise Inspect This sur un fichier, un projet ou la solution. L'analyse solution-wide peut également trouver des problèmes qui ne sont pas visibles dans le fichier courant, comme certains membres publics inutilisés.[2]

La navigation devient particulièrement utile dans un projet ASP.NET Core avec plusieurs couches (Controllers, Services, Repositories, Contracts, etc.). Les fonctions à privilégier sont :

aller à un fichier, un type ou un membre;
trouver toutes les utilisations d'une classe ou d'une méthode;
aller à l'implémentation d'une interface;
afficher les classes de base et les classes dérivées;
afficher la hiérarchie d'appels d'une méthode;
explorer les dépendances entre types ou projets;
prévisualiser les résultats avant de modifier le code.

Quand tu ne sais pas où une méthode est utilisée, commence par ses usages plutôt que par une recherche texte globale. ReSharper comprend les symboles C# et évite plusieurs faux positifs liés aux commentaires ou aux noms qui se ressemblent.

Completion et génération de code¶

La completion de base se lance avec Ctrl+Space. ReSharper peut proposer des noms selon le type et les conventions de nommage, comprendre les abréviations CamelHumps et importer automatiquement certains namespaces.[6]

Raccourcis pratiques du keymap Visual Studio :

Raccourci	Fonction
`Ctrl+Space`	Completion de symboles et génération contextuelle.
`Ctrl+Alt+Space`	Smart Completion, filtrée selon le type attendu.
`Alt+Shift+Space`	Import Symbol Completion, incluant des types d'autres namespaces.
`Alt+Insert`	Générer du code : constructeur, propriétés, overrides, membres, etc.
`Ctrl+E, L`	Insérer un live template.
`Ctrl+E, U`	Entourer une sélection avec un template.
`Ctrl+Shift+Enter`	Compléter une instruction.

Les commandes exactes peuvent changer si le keymap IntelliJ IDEA est sélectionné. ReSharper propose deux schemes principaux — Visual Studio et IntelliJ IDEA — et les raccourcis peuvent être modifiés dans Tools | Options | Environment | Keyboard.[10]

Exemple réel : ajouter une méthode à un service¶

Supposons qu'on ajoute une méthode à un service ASP.NET Core :

public interface IUserService
{
    Task<UserResponse?> GetByIdAsync(int id);
}

public sealed class UserService : IUserService
{
    public async Task<UserResponse?> GetByIdAsync(int id)
    {
        // logique existante
        return null;
    }
}

Un workflow ReSharper raisonnable serait :

Placer le curseur sur IUserService et utiliser la navigation vers les implémentations.
Utiliser Alt+Enter pour générer le membre manquant si l'interface a été modifiée.
Utiliser Alt+Insert pour générer un constructeur ou les membres répétitifs nécessaires.
Extraire une partie trop longue avec Ctrl+Shift+R puis Extract Method.
Renommer un paramètre avec Rename, plutôt que de faire un remplacement texte global.
Lancer les tests concernés.
Appliquer Code Cleanup sur les fichiers touchés seulement.
Vérifier le diff Git avant le commit.

Le point important est de laisser ReSharper faire les transformations structurelles, mais de garder la décision métier et la validation des tests entre les mains du développeur.

Code style et configuration d'équipe¶

Les préférences de style influencent la completion, la génération de membres, les templates et les refactorings. ReSharper peut détecter les violations et les corriger avec des quick-fixes ou Code Cleanup.[8]

Pour éviter que chaque développeur ait un résultat différent :

définis les conventions au niveau de la solution;
partage les préférences pertinentes dans un fichier .DotSettings versionné;
utilise aussi .editorconfig lorsque les règles doivent être comprises par plusieurs outils;
crée un profil de cleanup d'équipe plutôt que de dépendre du profil personnel de chacun;
limite les changements automatiques aux fichiers modifiés quand le projet est déjà en production.

Le cleanup peut lire les préférences de formatage, les styles syntaxiques, les en-têtes et la disposition des fichiers depuis les fichiers .DotSettings. Les règles .editorconfig applicables peuvent remplacer les réglages ReSharper dans leur portée.[5]

Intégration CI et ligne de commande¶

Pour vérifier le code sans ouvrir Visual Studio, JetBrains fournit les ReSharper Command Line Tools. InspectCode exécute des inspections et peut être intégré à une CI; CleanupCode reformate et nettoie une solution ou un ensemble de fichiers.[2][9]

Exemples de commandes documentées par JetBrains pour CleanupCode :

cleanupcode.exe YourSolution.sln
cleanupcode.exe File1 File2 File3

Un profil peut être choisi explicitement :

cleanupcode.exe --profile="Built-in: Reformat Code" YourSolution.sln

Avant d'utiliser CleanupCode sur une solution, la documentation recommande de la compiler avec la bonne configuration afin que les références binaires soient résolues correctement.[5]

À retenir: en CI, il vaut mieux commencer par un profil de formatage partagé et prévisible. Un profil qui réécrit trop de code peut générer un bruit important dans les pull requests.

Ce que ReSharper ne remplace pas¶

ReSharper est puissant, mais il ne remplace pas :

le compilateur;
les tests unitaires et d'intégration;
l'analyse des règles métier;
une revue de code;
les analyseurs de sécurité spécialisés;
la compréhension de l'impact fonctionnel d'un changement.

Une correction proposée peut être techniquement valide et quand même modifier le comportement ou nuire à la lisibilité du projet. Les refactorings doivent donc être suivis d'un build, des tests pertinents et d'une inspection du diff.

Problèmes fréquents¶

Les raccourcis ne fonctionnent pas¶

Vérifie le keymap actif dans les options de ReSharper. Le même raccourci peut produire une action différente selon que le scheme Visual Studio ou IntelliJ IDEA est utilisé.[10]

Il y a trop d'avertissements¶

Réduis le bruit au niveau de la solution ou de la catégorie d'inspection. Une règle importante doit rester visible; une préférence personnelle ne devrait pas noyer les erreurs réelles.

Le cleanup modifie trop de fichiers¶

Commence par un seul fichier, utilise git diff, puis applique le cleanup à une portée plus large seulement après avoir validé le profil.

L'analyse solution-wide est lente¶

Désactive-la temporairement pendant une grosse opération ou limite l'analyse à la portée utile. Pour un projet important, lance les analyses globales dans la CI plutôt que de garder toutes les fonctions lourdes actives en permanence sur une machine moins puissante.

ReSharper et Visual Studio se contredisent¶

Les deux outils peuvent avoir des règles de style ou des inspections similaires. Décide quelle configuration est la référence du projet et partage-la. Évite de corriger alternativement le même style avec deux profils différents.

Fonctions moins communes, mais utiles¶

Ces fonctions sont moins essentielles au quotidien, mais deviennent intéressantes dans un codebase plus gros :

diagramme de dépendances entre types et projets;
Value Tracking pour suivre l'origine et la destination d'une valeur;
call chains pour explorer les chemins d'appel;
inspections personnalisées basées sur Structural Search and Replace;
détection des duplications depuis les outils en ligne de commande;
assistance de débogage et inlay hints;
aide à l'internationalisation;
analyse de hiérarchie de fichiers et de membres;
fonctions spécialisées pour ASP.NET, Razor, XAML et d'autres technologies.

Résumé rapide¶

Besoin	Fonction à utiliser
Comprendre un avertissement	`Alt+Enter`
Renommer sans casser les références	`Rename`
Voir les transformations possibles	`Ctrl+Shift+R` / `Refactor This`
Trouver qui appelle une méthode	Usages et call hierarchy
Implémenter une interface	`Alt+Enter` ou génération de code
Générer un constructeur ou des propriétés	`Alt+Insert`
Nettoyer un fichier	`Ctrl+E, C`
Chercher un type rapidement	Navigation ReSharper
Uniformiser un projet	Profil `Code Cleanup` partagé
Vérifier en CI	`InspectCode` / `CleanupCode`

Sources officielles¶

Sources¶

[1] https://www.jetbrains.com/help/resharper/Introduction__Index.html [2] https://www.jetbrains.com/help/resharper/Code_Analysis__Index.html [3] https://www.jetbrains.com/help/resharper/Code_Analysis__Quick-Fixes.html [4] https://www.jetbrains.com/help/resharper/Refactorings__Index.html [5] https://www.jetbrains.com/help/resharper/CleanupCode.html [6] https://www.jetbrains.com/resharper/features/code_completion.html [7] https://www.jetbrains.com/resharper/features/code_refactoring.html [8] https://www.jetbrains.com/resharper/features/code_formatting.html [9] https://www.jetbrains.com/resharper/features/command-line.html [10] https://www.jetbrains.com/help/resharper/Reference__Keyboard_Shortcuts.html

Touches	Action
`?`	Ouvrir l'aide
`n`	Page suivante
`p`	Page précédente
`s`	Rechercher