Covariance con C# e Interfacce

Question

Non sono chiaro sul concetto di Covariance in C# quando si tratta di interfacce. Strettamente basato sul mio esempio qui sotto, questo è un esempio di Covariance, per favore descrivi perché o perché no.

class Program 
{ 
    static void Main() 
    { 
     ICarInterface car = new Car(); 
    } 
} 

interface ICarInterface 
{ 
    void Start(); 
} 

class Car : ICarInterface 
{ 
    public void Start() 
    { 

    } 
} 

Answer 1

Questo non è un esempio di covarianza, è solo un semplice esempio di polimorfismo. Here puoi trovare le differenze tra covarianza e polimorfismo

Answer 2

No, questa non è veramente covarianza. Questa è solo l'implementazione di un'interfaccia. In particolare, è un esempio di compatibilità di assegnazione . Poiché la classe Car implementa l'interfaccia ICarInterface, un oggetto Car può essere assegnato a una variabile di tipo ICarInterface. Un oggetto di un tipo più specifico (Car) è stato assegnato a un'area di archiviazione per un tipo meno specifico (ICarInterface), che funziona perché i due tipi sono compatibili ai fini dell'assegnazione.

La covarianza è una cosa leggermente diversa. Una relazione di tipo è covariante se conserva l'ordine dei tipi (dal più specifico al più generico). Ad esempio, IEnumerable<T> è covariante rispetto al tipo T, quindi conserva l'ordine dei tipi IEnumerable<Vehicle> (più generico) e IEnumerable<Car> (più specifico). (In questo esempio, assumiamo ovviamente che Car sia una sottoclasse di Vehicle).

Eric Lippert has written an excellent article that distinguishes between covariance and assignment-compatibility. Diventa leggermente tecnico e teorico, ma dovresti assolutamente leggerlo. Non lo farei giustizia cercando di sintetizzarlo ulteriormente qui.

Un esempio di covarianza più comprensibile (almeno secondo me) è la covarianza di tipo ritorno. È qui che l'override di una classe derivata di un metodo di classe base restituisce un tipo più specifico. Per esempio:

abstract class Habitat 
{ 
    public abstract Animal ApexPredator(); 
} 

class Savanna : Habitat 
{ 
    public override Lion ApexPredator() 
    { ... } 
} 

class Ocean : Habitat 
{ 
    public override Shark ApexPredator() 
    { ... } 
} 

In questo esempio, la classe astratta Habitat ha due sottoclassi concrete: Savanna e Ocean. Tutti gli habitat hanno un ApexPredator, che è di tipo Animal. Ma in un oggetto Savanna, il predatore dell'apice è un Lion, mentre in un oggetto Ocean, il predatore dell'apice è un Shark. Questo è legale e sicuro perché Lion e Shark sono entrambi i tipi di Animal s.

Sfortunatamente, C# non supporta la covarianza del tipo di ritorno. È, tuttavia, supportato da C++ (incluso C++/CLI), Java e una serie di altri linguaggi orientati agli oggetti.

Eccone altri concrete examples of covariance.

Answer 3

La covarianza è correlata all'interazione di sottotipi e generici. Poiché il tuo programma non coinvolge i generici, non è un esempio di covarianza.

Se U è un sottotipo di V (ad esempio U = Pear e V = Fruit), poi un tipo generico G<T> è detto essere covariante in T se G<U> è un sottotipo di G<V>.Ad esempio, IEnumerable<Pear> è un sottotipo di IEnumerable<Fruit>: qualcosa da cui si possono prendere le pere può essere utilizzato per ricavarne i frutti.

Se G inverte la relazione di sottotipo (G<V> è un sottotipo di G<U>), si dice che sia contravariant in T. Per esempio, Action<Fruit> è un sottotipo di Action<Pear>: qualcosa che si può mettere frutta in può essere utilizzato per mettere le pere in

Nel tuo esempio, né ICarInterface nè Car ha un parametro di tipo che potrebbe essere covarianti in

..

In particolare, in C#, un tipo generico è covariante in un parametro di tipo T se T è contrassegnato con out. È controverso in T se T è contrassegnato con in.