Как изменить порядок членов типа с помощью Resharper?

Ответ 1

Используйте функцию "Очистить код".

Порядок членов может быть настроен в параметрах ReSharper в языках, С#, макете членов-членов. Это хорошо документированная спецификация макета XML, которую ReSharper использует при переупорядочивании членов.

Ответ 2

Сортировка по умолчанию не активируется. Вы можете активировать его, открыв параметры переадресации, а затем перейдите сюда:

Ответ 3

В интересах людей, таких как я, которые приземлились на этот вопрос через веб-поиск, но обнаружили, что деталь вопроса не совсем то, что они ожидали, вам может понравиться, что вы можете перемещать отдельных членов вверх и вниз в файле, удерживая Ctrl-Alt-Shift, а затем нажимая стрелки вверх или вниз.

(Очевидно, что не автоматическое оформление в алфавитном порядке, заданное в теле вопроса, но это был ответ, который я надеялся найти в вопросе в названии.)

Ответ 4

Альтернативой рассмотрению является Regionerate. Мы используем и как ReSharper, но Regionerate соответствует нашим потребностям в создании регионов и сортировке/перегруппировке элементов. И все это настраивается, конечно.

UPDATE: мы вместо этого использовали ReSharper Code Cleanup.

Ответ 5

Две вещи: существует известное (но не задокументированное) условие, в котором условия предварительной компиляции (например, #if DEBUG) останавливают переупорядочение членов типа. http://youtrack.jetbrains.com/issue/RSRP-336643#tab=Comments Другими словами, если у вас есть #IF DEBUG, он не будет переупорядочиваться.

Недавно я также заметил, что в ReSharper 8.0.1 (и, возможно, более ранних версиях), что кнопка для возврата шаблона XML обратно к DEFAULT WITH REGIONS на самом деле не содержит каких-либо утверждений для включения группировки #REGION. Поэтому я взял шаблон StyleCop, который включает сортировку и добавление # REGION-ing для каждого члена типа. Если вы выберете CUSTOM TEMPLATE, тогда вставьте этот XML файл, он должен работать.

<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>

Ответ 6

В меню Visual Studio

ReSharper > Параметры > Средa > IntelliSense > Поведение завершения > Сортировка элементов (по алфавиту)

Ответ 7

Если вы переупорядочиваете параметры по определенным методам, вы можете использовать Refactor > Change Signature, если ваш курсор находится на имени метода. Я использую ярлыки IntelliJ, поэтому для меня команда Ctrl + Shift + R, а затем Ctrl + F6.

После этого появится диалоговое окно, которое позволит вам изменить параметры метода переупорядочения. Он даже реорганизует любые реализации интерфейса.