Come refactoring: dividere una classe in due che comunicano tramite un'interfaccia

Question

Sto solo iniziando il mio primo refattore su larga scala e ho bisogno di dividere una classe (purtroppo grande) in due, che poi comunicano solo tramite un'interfaccia. (My Presenter si è rivelato un controller e deve dividere la logica della GUI dalla logica dell'app). Utilizzando C # in VisualStudio 2008 e Resharper, qual è il modo più semplice per raggiungere questo obiettivo?

Quello che sto per provare è a) Raccogliere i membri per la nuova classe ed "estrarre nuova classe" b) ripulire il disordine risultante c) "Estrai interfaccia" d) inseguire eventuali riferimenti alla classe e convertirli in riferimenti di interfaccia

ma non l'ho mai fatto prima, e mi chiedo se qualcuno conosce qualche buon consiglio o idea prima di iniziare a strappare tutto a parte ... Grazie!

Answer 1

Piccoli passi.

Passaggio 1: apporta una piccola modifica utilizzando l'eccellente refactoring di Resharper.
Passaggio 2: test (preferibilmente unit test) per assicurarsi che il codice funzioni ancora
Passaggio 3: impegnarsi nel controllo del codice sorgente

Ripeti più volte questi 3 passaggi.

Forse questo non funzionerà se stai eseguendo una di quelle "deve essere un grande passo tutto in una volta" refactoring. Nel qual caso, fai quanti più piccoli refactoring possibile prima di fare il grande passo.

Answer 2

Chiamami alla vecchia maniera, ma personalmente utilizzo le funzioni automatiche che hai descritto solo quando si tratta di attività tecniche (come rinominare, ecc ...)

Per tutti gli altri refactoring, come l'estrazione di interfacce e simili, preferisco fare manualmente. Scoprirai che puoi fare ancora più refactoring e di solito il codice risulterà più pulito.

Answer 3

Ho solo un consiglio importante: assicurati assolutamente di poter tornare allo stato prima di iniziare il refactor senza perdere nulla. Quindi tuffati e provaci. Potresti finire per doverti fermare e ricominciare, ma non c'è nulla di cui aver paura (fintanto che hai seguito il mio unico consiglio). Imparerai molto facendo.

Answer 4

Prima una breve risposta qui, ho intenzione di scrivere un post sul blog a riguardo, grazie per un'idea!

Quindi, supponiamo di avere questo:

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

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

Per prima cosa dobbiamo convertire tutti gli usi dei membri diretti in indiretti, cioè qualificarli con il campo. Per fare ciò, utilizzare il refactoring di estrazione di superclasse per estrarre la porzione di Presenter in superclasse:

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

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

Crea campo in PresenterAndController che ne delegherà uno e utilizzerà Generate (Alt-Ins) per creare membri delegati. Nasconderanno i metodi di base, poiché sono gli stessi:

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

Rimuovi Presenter dall'elenco di ereditarietà e hai finito con la divisione delle classi. Ora puoi estrarre le interfacce, utilizzare i tipi di base ove possibile e in altro modo riordinare.

Answer 5

Non ho mai usato VisualStudio, ma trovo che il refactoring automatico in Eclipse sia abbastanza affidabile - almeno affidabile quanto farei lo stesso lavoro.

Answer 6

prima di farlo, investi nel controllo del codice sorgente: impara Git. Rifattorizzare senza SCM è come guidare con gli occhi bendati.