Devolución genérica sin saber tipo

Question

Tengo una situación en la que tengo una clase que acepta una instancia de un determinado tipo de objeto en su parámetro de tipo genérico. El diseño es algo como esto:

public abstract BaseClass { ... } 
public DiamondClass : BaseClass { ... } 
public SilverClass : BaseClass { ... } 

public Handler<T> where T : BaseClass { ... } 

Quiero para ser capaz de crear un método para devolver una instancia de Handler<DiamondClass> o Handler<BaseClass> sin definir el tipo al de entrada. He intentado algo en este sentido:

public Handler<BaseClass> GetHandler(HandlerType type) 
{ 
    switch(type) 
    { 
     case HandlerType.Diamond: return new Handler<DiamondClass>(); 
     case HandlerType.Silver: return new Handler<SilverClass>(); 
     default: throw new InvalidOperationException("..."); 
    } 
} 

Pero esto no va a funcionar, porque al parecer Handler<DiamondClass> no rechaza implícitamente a Handler<BaseClass>. Puedo especificar así:

public Handler<T> GetHandler<T>(HandlerType type) where T : BaseClass 
{ 
    switch(type) 
    { 
     case HandlerType.Diamond: return (Handler<T>)new Handler<DiamondClass>(); 
     case HandlerType.Silver: return (Handler<T>)new Handler<SilverClass>(); 
     default: throw new InvalidOperationException("..."); 
    } 
} 

Pero ahora tengo que llamar GetHandler<DiamondClass> o GetHandler<BaseClass>. Y eso frustra el propósito de tener un método que devuelva el controlador adecuado basado en una enumeración, sin saber el tipo. Tenía la esperanza de que pudiera definir un objeto Type y pasarlo, tales como:

Type objType = typeof(DiamondClass); 
var handler = Handler<objType>(); 

Pero al parecer, C# no voy a permitir que ese tipo de locura. He hecho esto de varias maneras diferentes, y me gustaría pensar que hay una manera de hacerlo, pero estoy perplejo.

---

(que en realidad no conseguir este trabajo mediante la devolución de un objeto dynamic, pero me gustaría evitarlo si es posible, ya que pierde cualquier tipo de seguridad y compatibilidad con IntelliSense.)

Answer 1

Este es

donde covarianza entra en juego, covarianza y contra-varianza acaba de trabajar sólo en la interfaz y delegado, por lo que, para resolver su problema, simplemente definir una nueva interfaz IHandler como co-variante con out que especifica que el parámetro de tipo es una variante:

public interface IHandler<out T> where T : BaseClass 
{ 
} 

Una interfaz que tiene un parámetro de tipo covariante permite a sus métodos para volver tipos más derivados de los especificados por el parámetro de tipo

va a trabajar. Más información es here