Cómo devolver el subtipo en el método reemplazado de la subclase en C#?

Question

Tengo una subclase con un método omitido que sé que siempre devuelve un subtipo particular del tipo de devolución declarado en la clase base. Si escribo el código de esta manera, no se compilará. Como eso probablemente no tiene sentido, déjeme dar un ejemplo de código:

class BaseReturnType { } 
class DerivedReturnType : BaseReturnType { } 

abstract class BaseClass { 
    public abstract BaseReturnType PolymorphicMethod(); 
} 

class DerivedClass : BaseClass { 
    // Compile Error: return type must be 'BaseReturnType' to match 
    // overridden member 'BaseClass.PolymorphicMethod()' 
    public override DerivedReturnType PolymorphicMethod() { 
     return new DerivedReturnType(); 
    } 
} 

¿Hay alguna manera de lograr esto en C#? Si no, ¿cuál es la mejor manera de lograr algo similar? ¿Y por qué no está permitido? No parece permitir ninguna incoherencia lógica, ya que cualquier objeto devuelto por el método over-ridden aún is BaseReturnType. Tal vez hay algo que no había considerado sin embargo. O tal vez la razón sea tecnológica o histórica.

Answer 1

Desafortunadamente no, los tipos de retorno covariantes no se admiten en C# para anulación de método. (Ditto tipos de parámetros contravariantes.)

Si está implementando una interfaz, puede implementarla explícitamente con la versión "débil" y también proporcionar una versión pública con el contrato más sólido. Para anulación simple de una clase principal, no tiene este lujo me temo :(

(EDITAR: Marc tiene un reasonable solution - aunque es bastante feo, y el método de ocultar es generalmente algo malo para la legibilidad. ofender, Marc;).

I creo esto es en realidad una restricción CLR, no sólo un lenguaje de uno - pero bien podría estar equivocado

(Como una cuestión de historia, Java (el lenguaje) tenía la misma restricción hasta 1.5, pero ganó covarianza al mismo tiempo que los genéricos).

Answer 2

Me parece que debe devolver una interfaz, no una clase base.

Answer 3

class BaseReturnType { } 
class DerivedReturnType : BaseReturnType { } 

abstract class BaseClass { 
    public abstract BaseReturnType PolymorphicMethod(); 
} 

class DerivedClass : BaseClass { 
    // Error: return type must be 'BaseReturnType' to match 
    // overridden member 'BaseClass.PolymorphicMethod()' 
    public override BaseReturnType PolymorphicMethod() { 
     return new DerivedReturnType(); 
    } 
} 

esto debería funcionar

Answer 4

Usted puede hacer esto si se introduce un método adicional para anular (ya que no se puede override y new un método con el mismo nombre en el mismo tipo):

abstract class BaseClass 
{ 
    public BaseReturnType PolymorphicMethod() 
    { return PolymorphicMethodCore();} 

    protected abstract BaseReturnType PolymorphicMethodCore(); 
} 

class DerivedClass : BaseClass 
{ 
    protected override BaseReturnType PolymorphicMethodCore() 
    { return PolymorphicMethod(); } 

    public new DerivedReturnType PolymorphicMethod() 
    { return new DerivedReturnType(); } 
} 

Ahora tiene un método PolymorphicMethod en cada nivel con el tipo correcto.

Answer 5

usted podría hacer la clase genérica si eso no te molesta:

class BaseReturnType { } 
    class DerivedReturnType : BaseReturnType { } 

    abstract class BaseClass<T> where T : BaseReturnType 
    { 
     public abstract T PolymorphicMethod(); 
    } 

    class DerivedClass : BaseClass<DerivedReturnType> 
    { 
     // Error: return type must be 'BaseReturnType' to match 
     // overridden member 'BaseClass.PolymorphicMethod()' 
     public override DerivedReturnType PolymorphicMethod() 
     { 
      return new DerivedReturnType(); 
     } 
    } 

Answer 6

modificar la firma método de clase derivada a:

public override BaseReturnType PolymorphicMethod() 
{ 
    return new DerivedReturnType();  
} 

C# no soporta tipos variante de retorno. Se puede extraer de este post una manera de hacer esto utilizando los genéricos ... http://srtsolutions.com/blogs/billwagner/archive/2005/06/17/covaraint-return-types-in-c.aspx

Aquí hay una muestra utilizando los genéricos en su modelo:

public class BaseReturnType 
{ 
} 
public class DerivedReturnType : BaseReturnType 
{ 
} 

public abstract class BaseClass<T> where T : BaseReturnType 
{ 
    public abstract T PolymorphicMethod(); 

} 

public class DerviedClass : BaseClass<DerivedReturnType> 
{ 
    public override DerivedReturnType PolymorphicMethod() 
    { 
     throw new NotImplementedException(); 
    } 
} 

Answer 7

genéricos no son necesariamente el camino a seguir. En particular, el tipo (de derivado) no se considera un tipo (de base).

Primero, agregue un nuevo método a su clase derivada que devolverá el valor con el tipo correcto.En segundo lugar, marque el método de anulación no invalidable y haga que delegue en su nuevo método.

Eso es todo. Has resuelto tu problema Las clases secundarias no podrán volver a expandir el tipo porque deben anular su nuevo método.

Pido disculpas si el código no es del todo correcto; Estoy acostumbrado a VB.net.

abstract class C1 { 
    public abstract IEnumerable<Byte> F1(); 
} 
class C2 : C1 { 
    public sealed override IEnumerable<Byte> F1() { 
     Return F2(); 
    } 
    public overridable IList<Byte> F2() { 
     Return {1, 2, 3, 4}; 
    } 
}