IEnumerable <T> conversione

Question

Dati i seguenti:

class Base<T> {/*...*/} 
class Der<T>: Base<T> {/*...*/} 

interface Sth<T>{ 
    IEnumerable<Base<T>> Foo {get;} 
} 

// and implementation... 
class Impl<T>: Sth<T> { 
    public IEnumerable<Base<T>> Foo { 
    get { 
     return new List<Der<T>>(); 
    } 
    } 
} 

Come posso ottenere questo per compilare? L'errore è, ovviamente, non la conversione implicita trovata dalla lista < Der < T >> alla lista < Base < T >>. Se lo lancio espressamente, si verifica InvalidCastException.

Answer 1

La conversione che si sta tentando di eseguire non è supportata dalla versione 3.5 di .NET Framework. Sarà supportato nella versione 4.0 (Visual Studio 2010) a causa dell'aggiunta di generic covariance/contravariance. Anche se questo non consentirà ancora di lanciare List<Der>-List<Base>, si vi permetterà di lanciare IEnumerator<Der> (che implementa la lista) per IEnumerator<Base>.

Nel frattempo, è possibile scrivere la propria classe che implementa IEnumerable<Base> e restituisce un costume IEnumerator<Base> che avvolge semplicemente List<Der> s' IEnumerator<Der>. In alternativa, se si utilizza .NET Framework versione 3.5, è possibile utilizzare Cast extension method, come suggerito da altri.

Answer 2

Per rendere più compilare ...

class Impl<T> : Sth<T> 
{ 
    public IEnumerable<Base<T>> Foo 
    { 
     get 
     { 
      return new List<Base<T>>(); //change the List type to Base here 
     } 
    } 
} 

Si può sempre fare qualcosa di simile anche, che sarebbe tornato l'IEnumerable della classe Base da un'implementazione di Der

class Impl<T> : Sth<T> 
{ 
    public IEnumerable<Base<T>> Foo 
    { 
     get 
     { 
      List<Der<T>> x = new List<Der<T>>(); 

      foreach (Der<T> dt in x) 
      { 
       yield return dt; 
      } 
     } 
    } 
} 

Answer 3

List<Der<T>> è non convertibile in List<Base<T>> perché quest'ultimo può avere un Base<T> aggiunto e il primo non può.

È possibile risolvere questo utilizzando il metodo di estensione Cast: return new List<Der<T>>().Cast<Base<T>>();

Answer 4

È possibile utilizzare LINQ per lanciare da List<Der<T>> a un IEnumerable<Base<T>>, utilizzando:

class Impl<T>: Sth<T> 
{ 
    public IEnumerable<Base<T>> Foo 
    { 
     get 
     { 
      return new List<Der<T>>().Cast<Base<T>>(); 
     } 
    } 
} 

Come le altre risposte hanno dichiarato, convariance generica è non supportato in v3.5, ma puoi usare LINQ per creare un oggetto wrapper che implementa IEnumerable<Base<T>>.

Answer 5

Queste risposte mi hanno aiutato, e volevo solo postare il mio soluzione per un problema simile che ho avuto.

Ho scritto un metodo di estensione per IEnumerable che proietta automaticamente TSource ogni volta che voglio convertire un elenco <Foo> a un oggetto IEnumerable <Bar> (Sono ancora in 3.5).

public static SpecStatus Evaluate<TSource, TSpecSource>(this IEnumerable<TSource> source, ISpec<IEnumerable<TSpecSource>> spec) 
     where TSource : TSpecSource 
{ 
    return spec.Evaluate(source.Cast<TSpecSource>()); 
}