C#: Transitive Eredità

Question

Ereditarietà una relazione transitiva in C#?

sto chiedendo perché non riesco a capire perché IList<T> implementa ICollection<T> e IEnumerable<T> come ICollection<T> implementa già IEnumerable<T>

Grazie per chiarire questo per me.

Answer 1

per quanto ne so, non ha veramente importa se dichiarato IList<T> come:

public interface IList<T> : ICollection<T>, IEnumerable<T> { ... } 

o semplicemente come:

public interface IList<T> : ICollection<T> { ... } 

Ogni classe che vuole implementare IList<T> dovrà implementare tutto di queste interfacce, cioè anche quelle ereditate.

Ovviamente, se avete implementato questa interfaccia senza implementare i metodi GetEnumerator delle interfacce IEnumerable/IEnumerable<T>, otterreste un errore del compilatore; questa "dimostrazione" per dimostrazione dovrebbe essere sufficiente a dirti che "l'ereditarietà dell'interfaccia" è transitoria, anzi.

---

Sidenote 1. Su un lato nota (e un po 'off-topic), considera che si può anche effettuare le seguenti operazioni:

class Base 
{ 
    public void Foo() { ... } 
} 

interface IFoo 
{ 
    void Foo(); 
} 

class Derived : Base, IFoo 
{ } 

Derived in realtà non implementare IFoo; la sua classe base Base fornisce il metodo Foo, ma non implementa esplicitamente lo IFoo stesso.

Questo si compila bene, apparentemente perché ci sono tutti i metodi richiesti dalle interfacce. (Lascerò a questo e per il momento lascerò da parte i discorsi tecnici esatti.)

Il motivo per cui sto menzionando questo fenomeno apparentemente non correlato è che mi piace pensare all'ereditarietà dell'interfaccia in questo modo: è necessario implementare tutti i metodi richiesti dalle interfacce specificate nella dichiarazione della classe. Così, quando vedo

interface ICollection<T> : IEnumerable<T> { ... } 

invece di dire, "ICollection<T> eredita IEnumerable<T>", potrei dire a me stesso, "ICollection<T> richiede di tutte le classi di attuazione che implementano IEnumerable<T>, anche."

---

Sidenote 2. Per concludere questa risposta con un altro aneddoto in qualche modo correlato (prometto che sarà l'ultimo):

Qualche tempo fa ho visto il video Inside .NET Rx and IObservable/IObserver in the BCL su Canale 9. Come potreste ora, quelle due nuove interfacce, in arrivo da Rx, sono stati introdotti nel BCL con .NET 4. Una cosa peculiare è che quando si iscrive un osservatore a un osservabile tramite observable.Subscribe(observer), tutto ciò che si ottiene è anonimo IDisposable. Perché?

Come i chiacchieroni spiegano in quel video, avrebbero potuto dato il IDisposable un nome più descrittivo (come ISubscription), tramite un nome di tipo "alias", definito come segue:

interface ISubscription : IDisposable {} 

Tuttavia, finalmente deciso contro questo. Hanno capito che una volta che un ISubscription viene restituito dal metodo Subscribe, non sarebbe più evidente che il valore restituito deve essere Dipose d.

Quindi questo è un altro lato leggermente problematico dell '"eredità di interfaccia" che è opportuno tenere a mente.

Answer 2

È transitivo sotto tutti gli aspetti. Probabilmente lo strumento che usi per esaminare la gerarchia dell'ereditarietà ha un certo modo di mostrarlo. Non c'è modo di non implementare un'interfaccia, sebbene tu possa implementarla esplicitamente e quindi nasconderla dall'intelligenza.

Come autore di IList è possibile scegliere liberamente di derivare da ICollection o da ICollection e IEnumerable. IEnumerable sarebbe ridondante in questo caso e contrassegnata dal resharper.