implementación de interfaces genéricos anidados

Question

tengo las siguientes clases/interfaces:

// Model 
public class A : IA { } 
// ModelLogic 
public class B : IB<A> { } 

// Model Interface 
public interface IA { } 
// ModelLogic Interface 
public interface IB<T> where T : IA { } 

intento crear una nueva instancia utilizando el siguiente código:

IB<IA> foo = new B(); 

estoy consiguiendo el error siguiente:

Cannot implicitly convert type 'B' to 'IB<IA>'. An explicit conversion exists (are you missing a cast?) 

¿Puede alguien explicar por qué esto no es posible?

Answer 1

OK, vamos a reemplazar con AFish, IA con IAnimal, B con Aquarium, y IB<T> con IContainer<T>. Y lo añadiremos un miembro de IContainer<T>, y una segunda aplicación de IAnimal:

// Model 
public class Fish : IAnimal { } 
public class Tiger : IAnimal { } 
// ModelLogic 
public class Aquarium : IContainer<Fish> 
{ 
    public Fish Contents { get; set; } 
} 

// Model Interface 
public interface IAnimal { } 
// ModelLogic Interface 
public interface IContainer<T> where T : IAnimal 
{ 
    T Contents { get; set; } 
} 

IContainer<IAnimal> foo = new Aquarium(); // Why is this illegal? 
foo.Contents = new Tiger(); // Because this is legal! 

se puede poner un tigre en foo - foo se escribe como un contenedor que puede contener cualquier animal. Pero solo puedes poner un pez en un acuario. Dado que las operaciones que puede realizar legalmente en un Aquarium son diferentes que las operaciones que puede realizar en un IContainer<IAnimal>, los tipos no son compatibles.

la función que desea se llama genérica covarianza interfaz y es apoyado por C# 4, pero hay que demostrar al compilador que nunca se va a poner un tigre en su tanque de peces. Lo que se quiere hacer es:

// Model 
public class A : IA { } 
// ModelLogic 
public class B : IB<A> { } 

// Model Interface 
public interface IA { } 
// ModelLogic Interface 
public interface IB<out T> where T : IA { } 

Aviso la anotación de covarianza en IB. Esto out significa que T solo se puede usar como salida, no como entrada. Si T es solo una salida, entonces no hay forma de que alguien coloque un tigre en esa pecera porque no hay una propiedad o método de "ponerlo en" posible.

Escribí una serie de artículos de blog mientras agregamos esa característica a C#; si usted está interesado en las consideraciones de diseño que entraron en la función, consulte:

http://blogs.msdn.com/b/ericlippert/archive/tags/covariance+and+contravariance/

Answer 2

para fijar su código, basta con cambiar

public interface IB<T> where T : IA { } 

a

public interface IB<out T> where T : IA { } 

Answer 3

No es fácil para ver cuando tienes interfaces vacías.Considere usted tiene un método M en la interfaz IB:

public interface IB<T> where T : IA 
{ 
    void M(T t); 
} 

Y aquí es la implementación de B:

public class B : IB<A> 
{ 
    public void M(A t) 
    { 
     // only object of type A accepted 
    } 
} 

Entonces usted tiene objeto C, que también implementa IA:

public class C : IA { } 

Así , si su código sería posible, puede llamar al:

IB<IA> foo = new B(); 
foo.M(new C()); 

El problema es que la clase B solo acepta objetos del tipo A. ¡Error!