Deriva da una classe base ma non include una condizione nel metodo della classe base

Question

Deriva da una classe base ma non include una condizione nel metodo della classe base

#1 da (6 voti)

6

Il codice corrente ha il seguente aspetto:

public class Details
{
    Public void Populate()
    {
         WriteChapterDetails();
    }

    public void WriteChapterDetails()
    {
       if ( includeHighDetails)        
       {
         \Do something
       }

       if (includeLowDetails)
       {
         \Do something
       }
    }
}

Ora voglio scrivere una nuova classe chiamata HighDetails che sarà copia della classe Details, tranne che non voglio che vada alla condizione if (includeLowDetails) .

Sto pensando di derivare una classe dalla classe Details come:

public class HighDetails()
{
  Public void Populate()
    {
         WriteChapterDetails();
    }

    public void WriteChapterDetails()
    {
       if ( includeHighDetails)        
       {
         \Do something
       }
}

La classe Details è una classe enorme e non voglio ripetere tutti i metodi nella classe HighDetails. Voglio derivare dalla classe Details e in qualche modo non includere LowDetails. Come posso farlo?

design c# refactoring design-patterns code-reuse

posta Tarveen 28.01.2015 - 19:59

fonte

1 risposta

Leggi altre domande sui tag design c# refactoring design-patterns code-reuse

Perché la sintassi dell'assembly AT & T è stata progettata in questo modo? Perché Apache 2.0 funziona escluso da OpenBSD?

score 6 · Accepted Answer

Questo è un tipo di problemi che devono essere affrontati utilizzando modello di metodo Template :

...behavioral design pattern that defines the program skeleton of an algorithm in a method, called template method, which defers some steps to subclasses. It lets one redefine certain steps of an algorithm without changing the algorithm's structure...

Applicato al tuo caso, potrebbe apparire come segue. Innanzitutto, definisci i passaggi dell'algoritmo che potresti dover modificare / ridefinire in sottoclassi mediante estraendo codice coinvolto in metodi separati.

In questo modo, WriteChapterDetails diventa uno scheletro come menzionato sopra:

    public void WriteChapterDetails()
    {
       WriteHighDetails();
       WriteLowDetails();
    }

    protected void WriteHighDetails()
    {
       if ( includeHighDetails)        
       {
         //Do something
       }
    }

    protected void WriteLowDetails()
    {
       if (includeLowDetails)
       {
         //Do something
       }
    }

In questo modo apre il codice per l'estensione nelle sottoclassi.

Successivamente, definisci la sottoclasse per sostituisci il passaggio desiderato dello scheletro:

public class HighDetails : Details
{
    protected override void WriteLowDetails()
    {
       //Do nothing
    }
}

In questo modo, HighDetails eredita tutto da Details tranne per la funzione che desideri eseguire in modo diverso ( WriteLowDetails ).

Nota a margine. Questo non è direttamente correlato a ciò che hai chiesto, ma i controlli condizionali come uno per includeHighDetails nel tuo snippet di codice sono codice -smell , suggerendo che potresti essere interessato a conoscere l'approccio di sostituendo il condizionale con il polimorfismo .

Inoltre sono rimasto un po 'sorpreso nel leggere il tuo reclamo sulla percentuale di classe Details . Il fatto è che il disegno disegnato nella domanda sembra essere compatto e praticamente autonomo. Se il codice reale si è mescolato in una "frittata" con materiale a malapena correlato / non correlato, è meglio investire qualche sforzo in estraendo questo funzionalità in una classe dedicata.