Perché una funzione che accetta IEnumerable <interface> non accetta IEnumerable <class>?

Question

Supponiamo, ad esempio, ho una classe:

public class MyFoo : IMyBar 
{ 
    ... 
} 

Poi, vorrei utilizzare il seguente codice:

List<MyFoo> classList = new List<MyFoo>(); 
classList.Add(new MyFoo(1)); 
classList.Add(new MyFoo(2)); 
classList.Add(new MyFoo(3)); 

List<IMyBar> interfaceList = new List<IMyBar>(classList); 

Ma questo produce l'errore:

`Argument '1': cannot convert from 'IEnumerable<MyFoo>' to 'IEnumerable<IMyBar>' 

Perchè è questo? Poiché MyFoo implementa IMyBar, ci si aspetterebbe che un IEnumerable di MyFoo possa essere trattato come un IEnumerable di IMyBar. Un banale esempio del mondo reale che sta producendo una lista di macchine, e poi viene detto che non era un elenco di veicoli.

E 'solo un disturbo secondario, ma se qualcuno può far luce su questo, mi sarebbe molto obbligata.

Answer 1

questo sta andando a lavorare in C# 4.0! Quello di cui parli si chiama covarianza generica.

Nel frattempo è possibile utilizzare il Cast extension method:

List<IMyBar> interfaceList = new List<IMyBar>(classList.Cast<IMyBar>()); 

Answer 2

Questo è supportato in .NET 4.0, ma non prima.

http://msdn.microsoft.com/en-us/library/dd799517%28VS.100%29.aspx

Answer 3

Per chiarire, il motivo per cui non funziona la società è perché IEnumerable<MyClass> non eredita da IEnumerable<MyBar>. Lo dirò di nuovo: l'enumerabile del tipo derivato non eredita dall'enumerabile del tipo base. Piuttosto, entrambi i tipi sono specializzati nel tipo generico IEnumerable<T>. In .Net 3.5 e versioni precedenti, non hanno altre relazioni oltre alla specializzazione (che non è ereditarietà) e sono altrimenti due tipi completamente diversi nel sistema dei tipi.

.Net 4.0 non cambierà il modo in cui questi tipi si riferiscono a tutti. Saranno comunque due tipi completamente diversi che riguardano solo la specializzazione. Quello che farà è consentire di scrivere metodi che conoscono la relazione di specializzazione e in alcuni casi consentire di sostituirne uno quando si scrive l'altro.

Answer 4

Se vuoi lanciare tra IEnumerables (come hai scritto nel titolo della tua domanda) e non tra le liste (come hai scritto nella tua domanda) si può attendere che la funzione di covarianza C# 4.0. Prima di quel giorno è possibile utilizzare i metodi di estensione. Ma non vorrei usare lo Cast extension method annotato in altre risposte, ma scrivendo il mio metodo, che può essere usato solo per la fusione di covarianza in IEnumerable. Quando/Se passi a C# 4.0 troverai facilmente tutti i posti nel tuo codice in cui il cast sarà ridondante.

public static class cEnumerableExtensions 
{ 
    public static IEnumerable<TResult> CovarianceConversion<TResult, TSource>(this IEnumerable<TSource> source) 
     where TSource : TResult 
    { 
     foreach (var item in source) 
     { 
      yield return item; 
     } 
    } 
} 

Nodo finale. Sembra che ci sia no precompiler constant for the netframework 4.0, altrimenti avrei aggiungere

#if DOTNET4 
    [Obsolete("You can directly cast in C# 4.0.")] 
    #endif