c# - studio - ¿Cómo reordenar los miembros de tipo con Resharper?

resharper visual studio code

Question

Escenario típico: una clase en la que mucha gente ha trabajado. Me gustaría ordenar métodos, propiedades, etc ... en orden alfabético.

Me gustaría poder hacer esto dentro de la región o globalmente en la clase.

Veo la función en Resharper para hacerlo, pero parece que no hace nada.

Answer 1

Desde el menú de Visual Studio;

ReSharper> Opciones> Entorno> IntelliSense> Comportamiento de finalización> Elementos de ordenación (alfabéticamente)

Answer 2

Dos cosas: existe una condición conocida (pero no muy documentada) en la que los condicionales de precompilación (# if DEBUG, por ejemplo) detendrán la reordenación de miembros de tipo. http://youtrack.jetbrains.com/issue/RSRP-336643#tab=Comments En otras palabras, si tiene #IF DEBUG no se volverá a ordenar.

Recientemente también me di cuenta de que en ReSharper 8.0.1 (y probablemente en versiones anteriores) el botón para revertir la plantilla XML a DEFAULT WITH REGIONS realmente no tiene ninguna declaración que incluya la agrupación #REGION. Así que tomé una plantilla amigable de StyleCop que incluye ordenar y agregué # REGION-ing a cada miembro del tipo. Si selecciona PLANTILLA PERSONALIZADA y luego pegue este XML, debería funcionar.

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

Answer 3

En beneficio de las personas, como yo, que llegaron a esta pregunta a través de una búsqueda en la web, pero descubrieron que el detalle de la pregunta no era exactamente lo que esperaban, le gustaría saber que puede mover miembros individuales hacia arriba y hacia abajo el archivo manteniendo presionadas las teclas Ctrl-Alt-Shift y luego presionando las flechas hacia arriba o hacia abajo.

(Obviamente, ese no es el arreglo automático por orden alfabético que se solicita en el cuerpo de la pregunta, sino que era la respuesta que esperaba encontrar para la pregunta en el título).

Answer 4

La ordenación no está activada por defecto. Puede activarlo abriendo las opciones de reafilar e ir aquí:

Answer 5

La respuesta de jgauffin está cerca, pero encontré que (con R # 2017) para reordenar las propiedades que necesitaba para hacer clic en la opción ''XAML'' en el encabezado del cuadro de diálogo Diseño de archivo y cambiar

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

a

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

La propiedad ''Sort By'' estaba vacía y de solo lectura, lo que tiene sentido porque solo se usa para elementos con el mismo nombre (y todas las propiedades deben tener un nombre exclusivo)

Answer 6

Si está reordenando parámetros en métodos específicos, puede usar Refactor> Cambiar firma si su cursor está en el nombre de un método. Yo uso los atajos IntelliJ, así que para mí, el comando es Ctrl + Shift + R seguido de Ctrl + F6.

Después de hacerlo, aparecerá un cuadro de diálogo que le permite los parámetros del método de reordenar. Incluso refactorizará cualquier implementación de una interfaz.

Answer 7

Una alternativa a considerar es Regionerate . Usamos y nos gusta ReSharper, pero Regionerate se ajusta a nuestras necesidades para crear regiones y ordenar / reorganizar los miembros. Y todo es personalizable, por supuesto.

ACTUALIZACIÓN: hemos empezado a usar el Código de limpieza de ReSharper para esto en su lugar.

Answer 8

Use la funcionalidad de "Código de limpieza".

El orden de los miembros se puede configurar en las opciones de ReSharper en Idiomas, C #, Tipo Diseño de miembros. Esta es una especificación de diseño XML bien documentada que ReSharper usa al reordenar miembros.