Interfaccia, astratto o solo metodi virtuali?

Question

Ho un sacco di sistemi, li chiamiamo A, B, C, D, E, F, G, H, I, J.

Hanno tutti metodi e proprietà simili. Alcuni contengono lo stesso metodo e le stesse proprietà, alcuni possono variare leggermente e alcuni possono variare molto. Al momento, ho un sacco di codice duplicato per ogni sistema. Ad esempio, ho un metodo chiamato GetPropertyInformation() definito per ciascun sistema. Sto cercando di capire quale metodo sarebbe il metodo migliore per ridurre il codice duplicato o forse uno dei metodi indicati non è la strada da percorrere:

interfaccia

public Interface ISystem 
{ 
    public void GetPropertyInformation(); 
    //Other methods to implement 
} 

public class A : ISystem 
{ 
    public void GetPropertyInformation() 
    { 
     //Code here 
    } 
} 

astratta

public abstract class System 
{ 
    public virtual void GetPropertyInformation() 
    { 
     //Standard Code here 
    } 
} 

public class B : System 
{ 
    public override void GetPropertyInformation() 
    { 
     //B specific code here 
    } 
} 

metodi virtuali in una classe Super Base

public class System 
{ 
    public virtual void GetPropertyInformation() 
    { 
    //System Code 
    } 
} 

public class C : System 
{ 
    public override void GetPropertyInformation() 
    { 
     //C Code 
    } 
} 

Una domanda, anche se può essere stupido, è supponiamo sono andato con l'approccio astratto e ho voluto ignorare il GetPropertyInformation, ma avevo bisogno di passare un parametro in più, è possibile questo o avrei dovuto creare un altro metodo nella classe astratta? Ad esempio, GetPropertyInformation(x)

Answer 1

Gli approcci astratti e di "classe base super" non sono molto diversi. Dovresti sempre rendere astratta la classe base e puoi fornire un'implementazione predefinita (metodi virtuali) o meno (metodi astratti). Il fattore decisivo è se tu voglia mai avere istanze della classe base, penso di no.

Quindi è tra la classe base e l'interfaccia. Se esiste un forte accoppiamento tra le classi A, B C, è possibile utilizzare una classe base e probabilmente un'implementazione comune.

Se le classi A, B, C non appartengono naturalmente a una singola "famiglia", utilizzare un'interfaccia.

E System non è un buon nome.

E non è possibile modificare l'elenco parametri quando si esegue l'override. Forse i parametri di default possono aiutare, altrimenti hai solo bisogno di 2 overload per GetPropertyInformation().

Answer 2

In genere si sceglie l'ereditarietà dell'oggetto quando si desidera condividere l'implementazione e ridurre quello che altrimenti sarebbe la duplicazione. Altrimenti le interfacce vincono perché sono più flessibili poiché non c'è bisogno di una classe base comune.

Per quanto riguarda l'override di un metodo e la modifica dell'elenco dei parametri che non è possibile. Immagina come chiameresti quel metodo su una classe base o su un riferimento all'interfaccia?

Answer 3

Vorrei andare con qualcosa di simile a quello che ho aggiunto di seguito. Otterrai comunque il vantaggio del contratto di interfaccia e dell'implementazione condivisa.

public Interface ISystem 
{ 
    public void GetPropertyInformation(); 
    //Other methods to implement 
} 

public abstract class System : ISystem 
{ 
    public virtual void GetPropertyInformation() 
    { 
     //Standard Code here 
    } 
} 

public class B : System 
{ 
    public string ExtendedSystemProp {get;set;} 

    public override void GetPropertyInformation() 
    { 
     base.GetPropertyInformation(); 

     var prop = "some extra calculating"; 

     GetExtraPropertyInformation(prop); 
    } 

    public void GetExtraPropertyInformation(string prop) 
    { 
     ExtendedSystemProp = prop; 
    } 
} 

ISystem genericSystem = new B(); 
genericSystem.GetPropertyInformation(); 

(genericSystem as B).ExtendedSystemProp = "value"; 

Answer 4

Non è possibile passare il parametro supplementare nel override. Quando si esegue l'override, si sta sovrascrivendo il metodo con la firma esatta. Ti suggerisco di passare un parametro di interfaccia come IPropertyInformation che può cambiare per implementazione.

La decisione di utilizzare una classe base o un'interfaccia per l'implementazione dipende in realtà dall'utilizzo. A-I hanno abbastanza in comune tra loro che dovrebbero derivare tutti dalla stessa classe base? Se è così, allora usa una classe base. È davvero sufficiente condividere solo GetPropertyInformation e diversamente i sistemi sono completamente funzionalmente diversi? Quindi vuoi davvero che condividano un'interfaccia.

Answer 5

Altri hanno coperto ciò che era originariamente nella mia risposta, ma riguardo al punto "aggiungi un parametro": non dimenticare che l'ultimo C# ti consente anche di avere parametri opzionali nei metodi.

Answer 6

Se non si dispone di un motivo valido altrimenti, andrei con l'interfaccia. I metodi virtuali pubblici, benché fatti molto, sono not ideal.