Eredità di interfaccia multipla

Question

Sto implementando un insieme di classi e interfacce corrispondenti dove voglio che ogni classe abbia un insieme di proprietà comuni e un insieme di proprietà specializzate che sono specifiche solo per quella classe. Così, Sto pensando di definire le interfacce lungo le linee di:

interface ICommon {...} // Members common to all widgets 
interface IWidget1 {...} // specialized members of widget type 1 
interface IWidget2 {...} // specialized members of widget type 2 

sto cercando di scegliere tra l'avere l'eredità nelle interfacce, o nella classe. Così, in particolare, posso neanche fare in questo modo:

interface IWidget1 : ICommon {...} 
interface IWidget2 : ICommon {...} 
class Widget1 : IWidget1 {...} 
class Widget2 : IWidget2 {...} 

... o così ...

class Widget1: ICommon, IWidget1 {...} 
class Widget2: ICommon, IWidget2 {...} 

C'è qualche motivo valido per andare in un modo o l'altro?

Aggiornamento: influenzerebbe la risposta se le classi devono essere COM-visibili?

Answer 1

È necessario scegliere l'ereditarietà dell'interfaccia se e solo se un tipo che implementa IWidget1 deve implementare anche ICommon. In entrambi i casi, la classe implementerà separatamente IWidget1 e ICommon. L'unica differenza è che se si rende IWidget1 "derivato" da ICommon, si impone il fatto che anche IWidget1 deve essere un ICommon.

Un buon esempio è IEnumerable e ICollection. Ogni ICollection è garantito come IEnumerable, quindi ICollection deriva da IEnumerable. Se era legale o aveva senso essere una raccolta ma non essere enumerabile, allora gli implementatori di ICollection non avrebbero dovuto implementare anche IEnumerable.

Quale che si sceglie non influirà sulla visibilità di COM. .NET continuerà ad esportare le interfacce separatamente se ricordo correttamente.

Answer 2

Utilizzare il Principio di sostituzione di Liskov per ottenere una risposta.

Se IWidget1 può essere sostituito da tutti i client che lavorano in ICommon1, è possibile ereditare IWidget1 da ICommon1. Se non vai con la classe implementando più interfacce.

Answer 3

L'ereditarietà dipende dall'attributo/comportamento della classe o dell'interfaccia. Se i comportamenti in IWidget1 e IWidget2 includono tutti i comportamenti in ICommon, allora si può sicuramente ereditare come IWidget1 : ICommon e IWidget2 : ICommon e non vi è alcun problema riguardante ComVisible. Questo è semplicemente il concetto di OOPS.

Answer 4

C'è un'altra considerazione che penso non sia stata presa in considerazione nelle altre risposte.

Se si deriva IWidgetX da ICommon, e poi arriva con un widget che ha il comportamento di entrambi IWidget1 e IWidget2 si può fare implementazione dell'interfaccia multipla:

class Widget3 : IWidget1, IWidget2 

Se entrambi interfaccia erano stati ricavati da ICommon, allora avrai due implementazioni di ICOMON nella tua classe. Questo non è un grosso problema e può essere gestito da multiple interface implementation, ma cambia la logica.

D'altra parte, se non derivano IWidgetX da ICommon, si può semplicemente implementare tutti e tre e non avere a che fare con esplicito implementazione:

class Widget3 : IWidget1, IWidget2, ICommon 

Quindi, se è concepibile che potrebbe essere necessario tale classe Widget3 - è meglio non derivare le interfacce IWidgetX da ICommon