¿Por qué la lista <T> no es válida en una interfaz covariante? MiInterfaz <out T>

Question

Pregunta de seguimiento a a previous question; esto se ha identificado como un problema de covarianza. Teniendo esto un paso más allá, si modifico IFactory como sigue:

class Program 
{ 
    static void Main(string[] args) 
    { 
     IFactory<IProduct> factory = new Factory(); 
    } 
} 

class Factory : IFactory<Product> 
{ 
} 

class Product : IProduct 
{ 
} 

interface IFactory<out T> where T : IProduct 
{ 
    List<T> MakeStuff(); 
} 

interface IProduct 
{ 
} 

consigo:

varianza no válido: El parámetro de tipo T debe ser invariantly válida en Sandbox.IFactory.MakeStuff(). T es covariante.

¿Por qué esto no es invariablemente válido? ¿Cómo puedo/debo resolver esto?

Answer 1

@Craig's answer es correcto. Para resolver, cambiarlo a:

IEnumerable<T> MakeStuff() 

EDIT: En cuanto al por qué, mira la definición de IEnumerable<T> Interface:

public interface IEnumerable<out T> : IEnumerable 

Tenga en cuenta que la IList<T> Interface no tiene la palabra clave a cabo. La varianza es compatible con los parámetros de tipo genérico en interfaces y delegados, no en clases, por lo que no se aplica a la lista <T>.

Answer 2

Como puede agregar y eliminar objetos de un List<T>, T siempre debe ser invariable, incluso si la lista es un resultado de la función. Después de haber ejecutado var l = MakeStuff(), puede colocar cosas en la lista o sacarlas, por lo que T debe ser invariante.

Answer 3

Las otras respuestas son correctas, pero es instructivo razonar por qué el compilador señala esto como inseguro. Supongamos que lo permitimos; ¿qué puede salir mal?

class Sprocket: Product {} 
class Gadget : Product {} 
class GadgetFactory : IFactory<Gadget> 
{ 
    public List<Gadget> MakeStuff() 
    { 
     return new List<Gadget>() { new Gadget(); } 
    } 
} 
... later ... 
IFactory<Gadget> gf = new GadgetFactory(); 
IFactory<Product> pf = gf; // Covariant! 
List<Product> pl = pf.MakeStuff(); // Actually a list of gadgets 
pl.Add(new Sprocket()); 

y hey, acabamos de agregar un piñón a una lista que solo puede contener gadgets.

Solo hay un lugar donde el compilador puede detectar el problema, y ​​eso está en la declaración de la interfaz.

Disculpe el mensaje de error algo excesivamente jerga. No podría pensar en nada mejor.