web-dev-qa-db-fra.com

Comment réorganiser les membres de type avec Resharper?

Scénario typique: un cours sur lequel beaucoup de personnes ont travaillé. J'aimerais trier les méthodes, les propriétés, etc. dans l'ordre alphabétique.

J'aimerais pouvoir faire cela dans la région ou globalement dans la classe.

Je vois la fonction dans Resharper pour le faire, mais cela ne semble rien faire.

c#resharper
42
AngryHacker

Utilisez la fonctionnalité "Code de nettoyage".

L'ordre des membres peut être défini dans les options ReSharper dans Langues, C #, Type de présentation des membres. Il s'agit d'une spécification de présentation XML bien documentée que ReSharper utilise lors de la réorganisation des membres.

82
Lucero

Le tri n'est pas activé par défaut. Vous pouvez l'activer en ouvrant les options de resharper puis en cliquant ici:

 enter image description here

46
jgauffin

Pour le bénéfice des personnes, comme moi, qui ont atterri sur cette question par le biais d'une recherche Web mais ont constaté que le détail de la question ne correspondait pas exactement à ce à quoi elles s'attendaient, vous voudrez peut-être savoir que vous pouvez déplacer des membres individuels de haut en bas le fichier en maintenant enfoncée la touche Ctrl-Alt-Maj, puis en appuyant sur les flèches vers le haut ou vers le bas.

(Évidemment, ce n'est pas l'arrangement automatisé par ordre alphabétique demandé dans le corps de la question, mais c'est la réponse que j'espérais trouver pour la question dans le titre.)

41
Ian Griffiths

Une alternative à considérer est Regionerate . Nous utilisons et aimons ReSharper, mais Regionerate répond à nos besoins de création de régions et de tri/réorganisation des membres. Et tout est personnalisable, bien sûr.

MISE À JOUR: Nous avons commencé à utiliser ReSharper's Code Cleanup pour cela à la place.

4
TrueWill

Deux choses: Il existe une condition connue (mais pas très documentée) où les conditions préalables à la compilation (#if DEBUG par exemple) cessent de réorganiser les membres du type . http://youtrack.jetbrains.com/issue/ RSRP-336643 # tab = Comments .__ En d'autres termes, si vous avez #IF DEBUG, il ne sera pas réorganisé.

J'ai aussi récemment remarqué que dans ReSharper 8.0.1 (et probablement des versions antérieures), le bouton permettant de rétablir le modèle XML en DEFAULT WITH REGIONS ne contient pas réellement d'instructions à inclure dans le groupement #REGION. J'ai donc pris un modèle convivial StyleCop qui inclut le tri et ajouté # REGION-ing à chaque type de membre. Si vous sélectionnez CUSTOM TEMPLATE puis collez ce XML, cela devrait fonctionner.

<Patterns xmlns="urn:shemas-jetbrains-com:member-reordering-patterns">

<!--  Do not reorder COM interfaces  -->
<Pattern>
    <Match>
        <And Weight="100">
            <Kind Is="interface" />
            <HasAttribute CLRName="System.Runtime.InteropServices.InterfaceTypeAttribute" />
        </And>
    </Match>
</Pattern>

<!--  Special formatting of NUnit test fixture  -->
<Pattern RemoveAllRegions="true">
    <Match>
        <And Weight="100">
            <Kind Is="class" />
            <HasAttribute CLRName="NUnit.Framework.TestFixtureAttribute" Inherit="true" />
        </And>
    </Match>

    <!--  Setup/Teardow  -->
    <Entry>
        <Match>
            <And>
                <Kind Is="method" />
                <Or>
                    <HasAttribute CLRName="NUnit.Framework.SetUpAttribute" Inherit="true" />
                    <HasAttribute CLRName="NUnit.Framework.TearDownAttribute" Inherit="true" />
                    <HasAttribute CLRName="NUnit.Framework.FixtureSetUpAttribute" Inherit="true" />
                    <HasAttribute CLRName="NUnit.Framework.FixtureTearDownAttribute" Inherit="true" />
                </Or>
            </And>
        </Match>
    </Entry>
    <!--  All other members  -->
    <Entry />
    <!--  Test methods  -->
    <Entry>
        <Match>
            <And Weight="100">
                <Kind Is="method" />
                <HasAttribute CLRName="NUnit.Framework.TestAttribute" Inherit="false" />
            </And>
        </Match>
        <Sort>
            <Name />
        </Sort>
    </Entry>
</Pattern>

<!--  Default pattern  -->


<Pattern RemoveAllRegions="false">
    <!--  Delegates  -->
    <Entry>
        <Match>
            <And Weight="100">
                <Access Is="public" />
                <Kind Is="delegate" />
            </And>
        </Match>
        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Name />
        </Sort>
        <Group Region="Delegates" />
    </Entry>


    <!--  Fields and constants  -->
    <Entry>
        <Match>
            <Or>
                <Kind Is="field" />
                <Kind Is="constant" />
            </Or>
        </Match>

        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Kind Order="constant" />
            <Readonly />
            <Static />
            <Name />
        </Sort>
        <Group Region="Fields" />
    </Entry>

    <!--  Enums  -->
    <Entry>
        <Match>
            <Kind Is="enum" />
        </Match>
        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Name />
        </Sort>
        <Group Region="Enums" />
    </Entry>

    <!--  Constructors. Place static one first  -->
    <Entry>
        <Match>
            <Kind Is="constructor" />
        </Match>
        <Sort>
            <Static />
            <Access Order="public internal protected-internal protected private" />
        </Sort>
        <Group Region="Constructors" />
    </Entry>

    <!--  Destructors. Place static one first  -->
    <Entry>
        <Match>
            <Kind Is="destructor" />
        </Match>
        <Sort>
            <Static />
            <Access Order="public internal protected-internal protected private" />
        </Sort>
        <Group Region="Destructors" />
    </Entry>


    <!--  Events  -->
    <Entry>
        <Match>
            <Kind Is="event" />
        </Match>

        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Name />
        </Sort>
        <Group Region="Events" />
    </Entry>

    <!--  Properties  -->
    <Entry>
        <Match>
            <And>
                <Kind Is="property" />
                <Not>
                    <Kind Is="indexer" />
                </Not>
            </And>
        </Match>
        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Static />
            <Abstract />
            <Virtual />
            <Override />
            <Name />
        </Sort>
        <Group Region="Properties" />
    </Entry>

    <!--  Indexers  -->
    <Entry>
        <Match>
            <Kind Is="indexer" />
        </Match>
        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Static />
            <Abstract />
            <Virtual />
            <Override />
            <Name />
        </Sort>
        <Group Region="Indexers" />
    </Entry>

    <!--  Methods  -->
    <Entry>
        <Match>
            <And>
                <Or>
                    <Kind Is="method" />
                    <Kind Is="operator" />
                    <HandlesEvent />
                </Or>
                <Not>
                    <Kind Is="destructor" />
                </Not>
            </And>
        </Match>
        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Static />
            <Abstract />
            <Virtual />
            <Override />
            <Name />
        </Sort>
        <Group Region="Methods" />
    </Entry>

    <!--  all other members  -->
    <Entry />

    <!--  nested types  -->
    <Entry>
        <Match>
            <Kind Is="type" />
        </Match>
        <Sort>
            <Access Order="public internal protected-internal protected private" />
            <Static />
            <Abstract />
            <Virtual />
            <Override />
            <Name />
        </Sort>
        <Group Region="Nested Types" />
    </Entry>
</Pattern>

3
Clint StLaurent

Si vous réorganisez des paramètres sur des méthodes spécifiques, vous pouvez utiliser le Refactor> Modifier la signature si votre curseur est sur un nom de méthode. J'utilise les raccourcis IntelliJ, donc pour moi la commande est Ctrl + Maj + R suivie de Ctrl + F6. 

 Refactor context menu

Ensuite, une boîte de dialogue apparaît pour vous permettre de modifier les paramètres de la méthode. Il va même jusqu'à refactoriser toutes les implémentations d'une interface.

0
birdamongmen

la réponse de jgauffin est proche, mais j'ai constaté que pour réorganiser les propriétés (avec R # 2017), je devais cliquer sur l'option "XAML" dans l'en-tête de la boîte de dialogue Disposition de fichier, puis

<Entry DisplayName="Properties, Indexers">
  <Entry.Match>
    <Or>
      <Kind Is="Property" />
      <Kind Is="Indexer" />
    </Or>
  </Entry.Match>
</Entry>

à

<Entry DisplayName="Properties, Indexers">
  <Entry.Match>
    <Or>
      <Kind Is="Property" />
      <Kind Is="Indexer" />
    </Or>
  </Entry.Match>
  <Entry.SortBy>
    <Name />
  </Entry.SortBy>
</Entry>

La propriété 'Trier par' était vide et en lecture seule, ce qui est logique car elle n'est utilisée que pour les éléments portant le même nom (et toutes les propriétés doivent porter un nom unique).

0
Robin Bennett