¿Cómo reordenar miembros de tipo con Resharper?

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

Utilice la funcionalidad "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.

Answer 2

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: Empezamos a usar ReSharper's Code Cleanup para esto en su lugar.

Answer 3

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

También recientemente noté que en ReSharper 8.0.1 (y probablemente en versiones anteriores) que el botón para revertir la plantilla XML de nuevo 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 4

Para el beneficio de la gente, como yo, que aterrizó en esta cuestión a través de una búsqueda en Internet, pero se ha encontrado que el detalle de la cuestión no era lo que esperaban, que le gustaría sepa que puede mover miembros individuales arriba y abajo dentro del archivo manteniendo presionadas las teclas Ctrl-Alt-Shift y luego presionando las flechas hacia arriba o hacia abajo.

(Obviamente eso no está pidiendo la disposición automatizada por orden alfabético en el cuerpo de la pregunta, pero era la respuesta que esperaba que iba a encontrar a la pregunta del título.)

Answer 5

Desde Visual Studio menú;

ReSharper> Opciones> Comportamiento medio ambiente> IntelliSense> Finalización> Ordenar elementos (en orden alfabético)

Answer 6

clasificación no está activado por defecto. Puede activarlo mediante la apertura de las opciones ReSharper y luego ir aquí:

Answer 7

Si está reordenando los parámetros sobre los métodos específicos, se puede utilizar el Refactor> Cambiar Firma si el cursor está en un nombre de 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, un cuadro de diálogo pop-up que le permite reordenar los parámetros del método. Incluso refactorizará cualquier implementación de una interfaz.