¿Por qué la restricción de genéricos no se puede convertir en su tipo derivado?

Question

Es bastante desconcertante descubrir que la restricción de genéricos no se puede convertir en su tipo derivado.

Digamos que tengo el siguiente código:

public abstract class BaseClass 
{ 
    public int Version 
    { get { return 1; } } 

    public string FixString { get; set; } 

    public BaseClass() 
    { 
     FixString = "hello"; 
    } 

    public virtual int GetBaseVersion() 
    { 
     return Version; 
    } 
} 

public class DeriveClass: BaseClass 
{ 
    public new int Version 
    { get { return 2; } } 
} 

Y adivina qué, este método devolverá un error de compilación:

public void FreeConversion<T>(T baseClass) 
    { 
     if(baseClass.GetType()==typeof(DeriveClass) 
     var derivedMe = (DeriveClass)baseClass; 
    } 

tendría que emitir el baseClass a object primero antes de que yo puede convertirlo a DerivedClass, es decir,

public void FreeConversion<T>(T baseClass) 
    { 
     if(baseClass.GetType()==typeof(DeriveClass) 
     var derivedMe = (DeriveClass)((object)baseClass); 
    } 

Me parece bastante feo. ¿Por qué esto es así?

Answer 1

En primer lugar, no debe convertir una variable de tipo base en un tipo derivado. Se supone que no funciona, solo al revés.

En segundo lugar, por qué funciona a través de object, es porque elimina las comprobaciones de tipo de tiempo de compilación. El compilador puede verificar que BaseType no se puede convertir a DerivedType. Pero cuando una variable es object, el compilador lo deja asumiendo que usted sabe lo que está haciendo. Incluso si se compila, el código se bloqueará durante la ejecución.

Answer 2

La respuesta es simple: el compilador no puede saber que T en su método FreeConversion se puede convertir en DeriveClass.

Answer 3

Como ya has dicho, el truco más barato es primero lanzarlo para objetar, luego al tipo al que quieres ir. Feo, pero funciona.

Aparte de eso, es posible que estés violando el principio de sustitución de Liskov, nada que perjudique a ningún animal, pero que puede llevar tu diseño a un código inmanejable.

En tercer lugar, un buen truco para que su clase base exponer el tipo derivado es algo como esto:

public class Base<T> where T : Base<T> { 
    T IAmDerived; 
} 

public class Derived : Base<Derived> { } 

Answer 4

En primer lugar, en su método genérico del tipo T podría ser un tipo de valle o de referencia tipo. Y la razón por la que te permite hacerlo a través de 'Objeto' es que, simplemente estás haciendo un boxeo-unboxing que funciona para cualquier tipo de sistema.

En segundo lugar, será una idea terrible convertir/convertir un objeto de clase base en una clase derivada. Estás violando la mecánica de OOP.

Si realmente desea devolver un objeto de tipo derivado de la clase base, aquí hay una forma posible: la solución es muy similar a la que Frank ha ofrecido.

//This is how you create a function in BaseClass that returns the collection 
//of DerivedTypes when called from an object of type derivedclass, no magic just Generics. 

//**The BaseClass** 
public class BaseClass<T> 
    where T : BaseClass<T> 
{ 
    public HashSet<T> GetHashSet() 
    { 
     HashSet<T> _hSet = new HashSet<T>(); 
     //do some work    
     //create a HashSet<T> and return;    
     return _hSet; 
    } 
} 
//**The Derived Class** 
public class DerivedClass : BaseClass<DerivedClass> 
{ 
    //you have the method inherited. 
}