Cómo refactorizar: divida una clase en dos que se comunican a través de una interfaz

Question

Me estoy embarcando en mi primer refactor a gran escala y necesito dividir una clase (desafortunadamente grande) en dos, que luego se comunican solo a través de una interfaz. (Mi presentador ha resultado ser un controlador y necesita dividir la lógica GUI de la lógica de la aplicación). Usando C # en VisualStudio 2008 y Resharper, ¿cuál es la forma más fácil de lograr esto?

Lo que voy a intentar es a) Reúna los miembros para la nueva clase y " extraiga la nueva clase " b) limpiar el desastre resultante c) " Extraer interfaz " d) persiga cualquier referencia a la clase y conviértala en referencias de interfaz

pero nunca he hecho esto antes, y me pregunto si alguien sabe algún buen consejo o problema antes de comenzar a destrozarlo todo ... Gracias!

Answer 1

Pasos de bebé.

Paso 1: realice un pequeño cambio con la excelente refactorización de Resharper.
Paso 2: Prueba (preferiblemente prueba de unidad) para asegurarse de que el código aún funciona
Paso 3: Comprometerse con el control de fuente

Repite estos 3 pasos muchas veces.

Tal vez esto no funcione si estás haciendo uno de esos " debe ser un gran paso de una vez " refactorizaciones. En cuyo caso, realice tantas refactorizaciones pequeñas como sea posible antes de sumergirse en el gran paso.

Answer 2

Llámame a la antigua usanza, pero personalmente, uso las funciones automatizadas que describiste solo cuando se trata de tareas técnicas (como cambio de nombre, etc.)

Para todas las demás refactorizaciones, como la extracción de interfaces, prefiero hacerlo manualmente. Descubrirá que puede hacer aún más refactorización y, por lo general, el código saldrá más limpio.

Answer 3

Solo tengo un consejo importante: asegúrate de que puedes volver al estado antes de comenzar el refactor sin perder nada. Entonces simplemente sumérgete y ve por ello. Puede que tengas que parar y comenzar de nuevo, pero eso no es nada de lo que tengas miedo (siempre y cuando hayas prestado atención a mi único consejo). Aprenderás mucho haciéndolo.

Answer 4

Respuesta corta aquí primero, voy a escribir una publicación en el blog al respecto, ¡gracias por una idea!

Entonces, asumamos que tenemos esto:

class PresenterAndController
  {
    public void Control()
    {
      Present();
    }

    public void Present()
    {
      // present something
    }
  }

Primero, debemos convertir todos los usos directos de los miembros en indirectos, es decir, calificarlos con el campo. Para hacer esto, use la extracción de superclase de extracción para extraer la parte de Presenter en la superclase:

  internal class Presenter
  {
    public void Present()
    {
      // present something
    }
  }

  class PresenterAndController : Presenter
  {
    public void Control()
    {
      Present();
    }
  }

Cree el campo en PresenterAndController que delegará uno y use Generar (Alt-Ins) para crear miembros delegados. Ocurrirán para ocultar métodos base, ya que son los mismos:

  internal class Presenter
  {
    public void Present()
    {
      // present something
    }
  }

  class PresenterAndController : Presenter
  {
    private Presenter myPresenter;

    public void Present() // hides base method
    {
      myPresenter.Present();
    }

    public void Control()
    {
      Present(); // it now references method from this type
    }
  }

Elimina a Presenter de la lista de herencia y habrás terminado de dividir las clases. Ahora puede extraer interfaces, usar tipos de base siempre que sea posible y, de lo contrario, ordenarlo.

Answer 5

Nunca he usado VisualStudio, pero me parece que la refactorización automática en Eclipse es bastante confiable, al menos tan confiable como lo estaría haciendo el mismo trabajo.

Answer 6

antes de hacerlo, invierte en control de código fuente: aprende Git. Refactorizar sin SCM es como conducir con los ojos vendados.