Refactorisations

La gamme de refactorisations de ReSharper surpasse celle qui est fournie par Visual Studio, autant au niveau du nombre que de sa facilité d'utilisation et de la portée de son application. Chaque refactorisation analyse l'intégralité de la portée de la sélection de code à laquelle il s'applique (jusqu'à l'intégralité de la solution), y compris le code multilingue, et utilise cette analyse pour mettre le code à jour de la manière la plus intelligente possible.

Toutes les refactorisations de ReSharper fonctionnent en C#, la majorité sont compatibles VB.NET, et certains acceptent ASP.NET, JavaScript, TypeScript, XAML et les autres langages pris en charge.

Vous pourriez aussi vouloir vérifier les actions contextuelles de ReSharper, qui implémentent des transformations de code moins sophistiquées et principalement locales, et non de véritables refactorisations, telles que définies par Martin Fowler.

Menu Refactor This en C#

Utilisation des refactorisations du code

Pour utiliser une refactorisation, vous pouvez placer le caret :

  • Sur un symbole dans l'éditeur de texte.
  • Sur une sélection de code dans l'éditeur de texte.
  • Sur un fichier ou une sélection de fichiers dans la fenêtre de l'outil Solution Explorer.
  • Sur un membre de type ou une sélection de membres de type dans File Structure ou une autre fenêtre d'outil ReSharper.

Ensuite, appelez la refactorisation requise depuis le menu Refactor de ReSharper ou en utilisant son raccourci clavier. Vous pouvez aussi utiliser la commande Refactor ThisCtrl+Maj+R — qui vous permet de voir quelles refactorisations peuvent être appliquées à la position de caret actuelle ou pour la sélection en cours.

Refactorisation Change Signature dans ReSharper

Change Signature

Cette refactorisation vous permet d'apporter les modifications suivantes à la signature d'une méthode :

  • Ajouter, supprimer, renommer ou réorganiser des paramètres
  • Changer le type de retour
  • Changer des types de paramètre
  • Renommer la méthode

En plus de changer la signature, ReSharper recherche toutes les utilisations de la méthode et modifie tous les appels, implémentations et contournements de la méthode pour refléter la modification. Dans le cas de paramètres fraîchement ajoutés, leurs valeurs par défaut fournies par l'utilisateur sont remplacées dans tous les appels de méthode. Pour les contournements, le paramètre original passé à la méthode est passé à l'appel de base.

Refactorisation Convert Extension Method to Static dans ReSharper

Convert Extension Method to Plain Static

Cette refactorisation sans dialogue convertit une méthode d'extension en méthode statique de la même classe. La fonctionnalité inverse est fournie par Convert Static to Extension Method.

Convert Static to Extension Method

Cette refactorisation convertit une méthode statique en méthode d'extension. Pour que la conversion soit réussie, la méthode statique doit (1) avoir au moins un argument et (2) se trouver dans une classe statique. La fonctionnalité inverse est disponible avec Convert Extension Method to Plain Static.

Conversion d'une interface en classe abstraite avec une refactorisation de ReSharper

Convert Interface to Abstract Class

Il est recommandé d'utiliser cette refactorisation si vous voulez ajouter de la logique à une interface ou si vous sentez qu'il vaudrait mieux que cela soit une classe. La refactorisation vérifie la présence de conflits, par exemple pour les types implémentant l'interface qui a déjà un type de base (une erreur en C#, qui n'a pas d'héritage multiple).

Convert Abstract Class to Interface

Vous pouvez appliquer cette refactorisation pour convertir une classe abstraite en interface. Cette opération est particulièrement pratique quand vous voulez qu'une classe hérite de plus d'une classe abstraite. Vous devez alors en convertir une en interface.

Refactorisation Extract Superclass dans ReSharper

Extract Superclass

Avec cette refactorisation, vous pouvez créer une classe de base pour une classe et y déplacer des membres. Placez simplement le caret à la déclaration de la classe, sélectionnez les membres à extraire et exécutez la refactorisation. Cette opération est très pratique pour faire monter une logique dans la hiérarchie d'héritage afin de la partager plus tard.

Refactorisation Introduce Parameter dans ReSharper

Introduce Parameter

Sélectionnez une expression ou une variable locale dans une méthode et utilisez cette refactorisation pour créer un nouveau paramètre à partir de celle-ci. Tous les sites d'appel seront actualisés pour refléter la modification de signature tout en conservant la logique et la sémantique.

Si une expression utilise des variables locales inaccessibles depuis un site d'appel, cette refactorisation permet de les passer en tant que déléguées.

Make Method Static/Shared

Cette refactorisation convertit une méthode non statique en méthode statique (Shared dans VB.NET) en faisant de this un paramètre de la méthode. Après la refactorisation, la méthode cible sera déclarée comme statique (Shared dans VB.NET) et les paramètres nécessaires seront ajoutés à ses sites d'appel. La refactorisation est aussi pratique quand vous voulez déplacer des méthodes non statiques (non-Shared dans VB.NET). Dans ce cas, utilisez Make Method Static comme étape de préparation pour la refactorisation Make Method Non-static.

Make Method Non-Static/Non-Shared

Cette refactorisation convertit une méthode statique (Shared dans VB.NET) en une méthode d'instance dans le type du paramètre sélectionné (c'est-à-dire déplace la méthode dans le type du paramètre et transforme le paramètre en this) et transforme les appels de la méthode en fonction.

Méthode déplacez l'instance

Utiliser cette refactorisation vous permet de déplacer rapidement une méthode d'instance depuis le type actuel vers l'un des types qui apparaît dans les paramètres de la méthode.

Move Static Member

La refactorisation déplace des champs et méthodes statiques vers un autre type. Si vous voulez déplacer des méthodes non statiques, utilisez à la place Move Instance Method.

Move String to Resource

Cette refactorisation fait partie du pack de la fonctionnalité internationalisation de ReSharper et facilite l'extraction des chaînes à localiser vers des fichiers de ressources. Pendant la refactorisation, les utilisations de chaînes explicites sont remplacées par des références à des wrappers de ressource.

Vous pouvez appeler cette refactorisation avec son raccourci dédié ou avec la commande Refactor This. Cependant, ReSharper peut également utiliser l'inspection de code pour mettre en valeur les chaînes qui ne sont pas dans des fichiers de ressources et suggérer la refactorisation Move String to Resource comme correctif rapide. Consultez l'aide de ReSharper pour découvrir comment configurer ReSharper pour lui permettre de faire cela.

Pull Members Up

Cette refactorisation vous aide à déplacer des membres de type vers une superclasse ou une interface. Cette opération est utile pour généraliser un comportement. ReSharper analyse tous les membres de la classe actuelle et crée une liste de ceux que vous pouvez faire remonter. Avant de terminer la refactorisation, ReSharper recherche également les conflits possibles, comme, par exemple, si les membres que vous essayez de déplacer dans une superclasse seront accessibles dans le type destination. La fonctionnalité inverse est disponible avec Push Members Down.

Push Members Down

Cette refactorisation vous aide à nettoyer votre hiérarchie de types en déplaçant les membres de types vers un sous-type. Cette opération est une bon moyen de spécialiser un comportement. ReSharper analyse tous les membres du type sélectionné et crée une liste de ceux que vous pouvez faire descendre. Avant de terminer la refactorisation, ReSharper recherche également les conflits possibles, comme par exemple, si les membres que vous essayez de faire descendre seront accessibles dans le type destination. La fonctionnalité inverse est disponible avec Pull Members Up.

Refactorisation Pull Parameter dans ReSharper

Pull Parameter

Quand vous ajoutez un nouveau paramètre à une méthode, soit via un correctif rapide, soit via la refactorisation Change Signature, non seulement ReSharper met à jour la signature et toutes les utilisations de la méthode, mais il analyse en plus la chaîne d'appel dont fait partie la méthode et vous permet « d'extraire » le nouveau paramètre où qu'il soit dans cette chaîne.

Refactorisation Rename dans XAML

Rename

La refactorisation Rename vous permet de renommer n'importe quel symbole, dont : les espaces de nom, les types, les méthodes, les paramètres, les variables locales, les propriétés, les champs et des événements. Elle trouve et corrige automatiquement toutes les références au symbole. La refactorisation Rename peut être invoqué directement depuis l'éditeur et, parfois, depuis d'autres vues (Class View, Object Browser).

Rename fonctionne avec tous les langages et technologies pris en charge, dont C#, VB.NET, JavaScript, ASP.NET, XML, XAML et les scripts de build.

La correction automatique de références est pleinement étendue au balisage XAML quand vous utilisez la refactorisation Rename. De plus, les symboles XAML spécifiques, comme les ressources et alias d'espace de nom, peuvent être facilement renommés.

Pour les scripts de build, quand vous renommez une propriété ou une cible avec ReSharper, toutes ses références et même ses utilisations dans les commentaires et chaînes sont automatiquement actualisées pour refléter les modifications.

Refactorisation Transform Parameters dans ReSharper

Transform Parameters

Cette refactorisation crée une nouvelle classe ou struct, et convertit les paramètres de la méthode sélectionnée en champs compris dans le type nouvellement créé. Les utilisations des paramètres sont converties en utilisations des propriétés du type qui vient d'être créé.

Il vous permet également de vous débarrasser des paramètres out : pour les méthodes void, un ou plusieurs paramètres out sont convertis en un retour qui utilise un objet tuple si nécessaire. Les méthodes non void peuvent être combinées avec le type de retour, grâce à un objet tuple.

La refactorisation Transform Parameters combine et remplace deux autres refactorisations : Transform Out Parameters et Extract Class from Parameters.

Replace Constructor with Factory Method

Cette refactorisation encapsule un constructeur dans une méthode statique qui renvoie une nouvelle instance d'une classe.

Le schéma Factory Method est un moyen de créer des objets sans spécifier la classe exacte de ces derniers. ReSharper génère une méthode séparée pour la création d'objets. Les sous-classes peuvent le forcer pour spécifier le type dérivé de l'objet qui sera créé.

Use Base Type where Possible

Avec cette refactorisation, votre code est généralisé en remplaçant les utilisations d'un type particulier par des références à son type de base ou à l'interface dès que possible. C'est-à-dire là où aucun membre du type dérivé n'est utilisé. Cette opération est particulièrement utile après la refactorisation Pull Members Up.

Copy Type

Il ne vous faut qu'une seconde pour créer une copie d'un type avec un nom différent ou dans un autre espace de nom. ReSharper s'occupera de créer un fichier séparé pour lui. Pour les types partiels, toutes les parties seront copiées même si elles se trouvent dans des fichiers séparés.

Convert Anonymous to Named Type

Cette refactorisation convertit les types anonymes en types nommés dans la portée de la méthode actuelle (localement) ou de toute la solution (globalement). Dans la boîte de dialogue fournie par cette refactorisation, vous pouvez indiquer si ReSharper doit générer des propriétés automatiques ou des propriétés avec champs de stockage, et également opter de générer des surcharges de méthode d'égalité et de mise en forme.

Convert Indexer to Method

Cette refactorisation est très proche de Convert Property to Method, mais s'applique aux indexeurs (propriétés par défaut dans VB.NET). Vous pouvez convertir uniquement les getters, uniquement les setters, ou les deux, en une méthode. La fonctionnalité inverse est fournie par Convert Methode to Indexer.

Convert Method to Indexer

Voici l'inverse de Convert Indexer to Methode. Il fonctionne en mode sans dialogue, mais vous pouvez l'appliquer à deux méthodes pour générer à la fois un getter et un setter dans votre indexeur.

Convert Method to Property

Cette refactorisation permet aux utilisateurs de convertir des méthodes non void sans paramètre en propriétés avec accès lecture, et des méthodes void avec exactement un paramètre en propriétés avec accès écriture. Les méthodes appariées peuvent être converties en une seule propriété lecture/écriture.

Convert Property to Auto-Property

Cette refactorisation vous aide à convertir les propriétés avec champs de stockage privés en propriétés automatiquement implémentées (aussi appelées propriétés automatiques). La refactorisation supprime le champ de stockage et remplace toutes ses utilisations par la propriété automatique nouvellement créée.

Refactorisation Convert Property to Method dans ReSharper

Convert Property to Method

Avec cette refactorisation, les propriétés avec accès lecture peuvent être converties en méthodes de type getter (méthodes non void sans paramètre), et les propriétés avec accès écriture peuvent être converties en méthodes de type setter (méthodes void avec exactement un paramètre). Pour ce qui est des propriétés avec accès à la fois lecture et écriture, vous pouvez les convertir en paires de méthodes de type getter et setter.

Refactorisation Extract Class dans ReSharper

Extract Class

Vous avez une classe qui effectue un travail qui aurait dû être effectué par deux classes différentes ? Utilisez cette refactorisation pour décomposer une classe complexe en deux classes à responsabilité unique. Extract Class vous permet de choisir les méthodes et champs à déplacer de l'ancienne classe vers la nouvelle. Il vous prévient aussi des dépendances cassées et des problèmes d'accessibilité, et suggère des options de résolution de conflit.

Extract Interface

Cette refactorisation vous permet de créer une interface à partir d'une classe et de demander à cette classe d'implémenter l'interface créée. Vous pouvez choisir les membres à extraire vers l'interface et donner un nom à cette dernière.

Extract Method

Sélectionnez un bloc de code et invoquez la refactorisation Extract Method pour le transformer en une méthode (Sub ou Function dans VB.NET). ReSharper va automatiquement analyser le code pour détecter la valeur de retour et/ou les paramètres out/ref.

Introduce Field

Sélectionnez une expression ou une variable locale et appliquez cette refactorisation. Il va créer un nouveau champ ou constante et l'initialiser avec l'initialiseur d'expression ou de variable locale. Le champ peut être assigné dans son initialiseur, ses constructeurs de type ou ses membres actuels.

Inline Field

Quand un champ possède une seule utilisation écriture, cette refactorisation remplace les utilisations lecture du champ par son expression d'initialisation, ce qui supprime au passage la déclaration du champ et l'utilisation écriture.

Encapsulate Field

La refactorisation Encapsulate Field vous permet de créer rapidement une propriété accessor à partir d'un champ existant. Les utilisations du champ sont automatiquement remplacées par les utilisations de la propriété. Un avantage manifeste de cette refactorisation est qu'elle vous permet d'interdire l'accès direct à un champ via l'utilisation des propriétés.

Inline Method

Dès que possible, cette refactorisation est en mesure de transférer le corps d'une méthode dans le corps de ses appelants et de supprimer en même temps la méthode. La fonctionnalité inverse est fournie par Extract Method.

Introduction d'une variable grâce à la refactorisation de ReSharper

Introduce Variable

Sélectionnez une expression arbitraire dans le code du membre et invoquez la refactorisation Introduce Variable. Une nouvelle variable locale typée implicitement ou explicitement sera déclarée et initialisée avec l'expression sélectionnée. L'expression originale sera remplacée par le nom de la variable. Si votre code contient plusieurs occurrences de l'expression d'origine, il vous sera proposé une option pour toutes les remplacer par la variable nouvellement créée. Similairement, vous pouvez aussi introduire des constantes pour des expressions constantes.

Inline Parameter

Cette refactorisation vous aide à déplacer un paramètre d'une méthode dans son corps. Par exemple, si la même valeur de constante est passé à la méthode dans tous ses appels, alors le paramètre peut être supprimé et la variable locale correspondante peut être ajoutée au corps de la méthode.

Inline Variable

Sélectionnez une variable arbitraire ou une constante locale, et invoquez la refactorisation 'Inline Variable'. Toutes les occurrences dans votre code de la variable sélectionnée seront remplacées par son initialiseur. La fonctionnalité inverse est fournie par Introduce Variable.

Refactorisation Introduce Variable for Substring

Introduce Variable for Substring

Cette refactorisation vous aide à déplacer rapidement une partie de chaîne vers une variable séparée. En fonction de la version C# de la cible, la refactorisation utilisera soit une interpolation de chaîne, soit un encadrement de la chaîne dans String.Format().

Refactorisation Move Types into Matching Files in ReSharper

Move Types into Matching Files

Cette refactorisation peut être appliquée à un fichier seul ou à une sélection de fichiers qui ont chacun plusieurs types. ReSharper crée des fichiers dédiés pour chacun de ces types et les déplace là.

« Move Types into Matching Files » est un assistant indispensable si vous préférez d'abord utiliser des types, puis les déclarer avec la fonctionnalité Create from Usage de ReSharper.

Un raccourci est disponible pour cette refactorisation, il vous suffit d'appuyer sur Alt+Entrée sur le nom d'une classe qui ne correspond pas au nom du fichier dans lequel elle se trouve.

Move to Folder

Cette refactorisation aide à déplacer une classe, un fichier ou une sélection de classes ou fichiers vers un autre projet ou dossier de la solution. Quand vous déplacez, ReSharper met à jour grâce aux directives, si nécessaire. Vous avez aussi la possibilité de renommer les espaces de nom en fonction du nouvel emplacement et de distribuer les classes déplacées dans des fichiers séparés.

Move Type to Outer Scope

Cette refactorisation déplace un type interne vers un niveau supérieur. Si le type interne utilise des membres du type encapsulé, une référence à ce dernier est passée sous la forme d'un argument aux constructeurs du type déplacé. Cette refactorisation peut être utilisée via la commande Move.

Move Type to Another File or Namespace

Vous pouvez facilement déplacer des types entre des espaces de nom, en sachant que les références sont automatiquement mises à jour par ReSharper. Vous pouvez également déplacer un type vers une portée extérieure ou imbriquée, ou vers un autre fichier.
Cette refactorisation vous permet de déplacer rapidement le code qui implémente un type donné vers un autre fichier. Cette refactorisation peut être utilisée via la commande Move.

Quand vous utilisez XAML et que vous déplacez une classe .NET vers un autre espace de nom, les références de balisage XAML vers la classe sont mises à jour et les directives d'importation XAML sont insérées/modifiées en fonction. Cette refactorisation peut également être invoqué directement depuis le balisage XAML de n'importe quelle référence de type.

Safe Delete

Si vous comptez supprimer un type, un membre de type ou tout autre symbole de fichiers de code C# ou VB.NET, de balisage ou code ASP.NET, de scripts de build, ou de XAML, utilisez cette refactorisation pour vous assurer que l'opération de suppression soit sécurisée. Si aucune utilisation de symbole n'est trouvée, ou si celles trouvées sont facilement réductibles, le symbole est supprimé. Sinon, ReSharper vous affiche toutes les utilisations dont la suppression n'est pas sûre, ce qui vous permet d'éditer le code correspondant.

Cette refactorisation peut être appliqué à une sélection de fichier ou membres de fichier, ce qui vous permet de supprimer des sous-systèmes entiers en toute sécurité.

Quand vous invoquez Safe Delete sur une cible ou une propriété d'un fichier de build, ReSharper s'occupe de toutes les validations et opérations nécessaires pour supprimer le symbole sélectionné. ReSharper peut également supprimer toutes les références conflictuelles pour vous.

Refactorisation Extract Members to Partial

Extract Members to Partial

Cette refactorisation vous permet de déplacer rapidement des membres de type entre différentes parties de type de classes partielles. En fonction de votre saisie, la refactorisation utilise des parties de type existantes ou en crée de nouvelles.

Vous pouvez même invoquer la refactorisation sur un #region pour déplacer tous les membres de la région vers un nouveau fichier dont le nom dépend du nom de la région.

Remarque sur les raccourcis

Tous les raccourcis clavier indiqués sur cette page sont disponibles dans la configuration clavier "Visual Studio" par défaut de ReSharper . Pour en savoir plus sur les deux configurations clavier de ReSharper, consultez la Documentation ReSharper.