Fundición de tipo C# en una interfaz genérica

Question

Estoy escribiendo una biblioteca que representa un grupo de objetos secundarios para revisar. El objeto secundario es abstracto, y está destinado a que los usuarios de esta biblioteca obtengan su propio hijo de esta clase abstracta.

public abstract class Child : IRenderable {} 

public interface IParent<T> where T : Child 
{ 
    IEnumerable<T> Children { get; } 
} 

La complicación es que no tengo una lista de iParent a trabajar, en cambio, tengo un montón de IRenderables. Se espera que el usuario de la biblioteca para escribir algo como esto:

public class Car : IRenderable { } 
public class Cow : IRenderable, IParent<Calf> { } 
public class Calf : Child { } 

// note this is just an example to get the idea 
public static class App 
{ 
    public static void main() 
    { 
     MyLibraryNameSpace.App app = new MyLibraryNameSpace.App(); 
     app.AddRenderable(new Car()); // app holds a list of IRenderables 
     app.AddRenderable(new Cow()); 
     app.Draw(); // app draws the IRenderables 
    } 
} 

En Draw(), el elenco de la biblioteca debe y comprobar si el IRenderable es también un iParent. Sin embargo, dado que no sé nada sobre el ternero, no sé a qué echarle la vaca.

// In Draw() 
foreach(var renderable in Renderables) 
{ 
    if((parent = renderable as IParent<???>) != null) // what to do? 
    { 
     foreach(var child in parent.Children) 
     { 
      // do something to child here. 
     } 
    } 
} 

¿Cómo puedo solucionar este problema? ¿Tiene esto algo que ver con los genéricos de covarianza o con lo que nunca (no estoy familiarizado con el concepto de covarianza)?

Answer 1

Desde IParent<T> sólo vuelve artículos de tipo T, usted podría hacerlo covariante utilizando el out modifier:

public interface IParent<out T> where T : Child 
{ 
    IEnumerable<T> Children { get; } 
} 

Esto haría IParent<anything> convertibles en IParent<Child>:

IParent<Child> parent = renderable as IParent<Child>; // works for Cow 

---

Nota esa covarianza solo funciona siempre y cuando Usted solo está devolviendo objetos de tipo T (simplemente hablando). Por ejemplo, tan pronto como se agrega un método AddChild(T) a su interfaz IParent, covarianza debe romper (= el compilador se quejará), ya que, de lo contrario, el siguiente código de tipo inseguro podría escribirse:

IParent<Child> parent = renderable as IParent<Child>; 
parent.AddChild(new Kitten()); // can't work if parent is really a Cow.