Soluzione alternativa per mancanza di tipo covarianza di ritorno quando si annullano i metodi virtuali

Question

esiste un modo per eseguire l'override covariante di "hack" o "coerce" in C#?

Ad esempio:

public class Alpha { 
    public virtual Alpha DoSomething() { 
     return AlphaFactory.GetAlphaFromSomewhere(); 
    } 
} 
public class Beta : Alpha { 
    public override Beta DoSomething() { 
     return BetaFactory.GetBetaFromSomewhere(); 
    } 
} 

Purtroppo, C# non supporta questo (che sembra un po 'ridicolo, ma questo è né qui né là).

ho pensato che avrei potuto avere una risposta con il metodo del nascondiglio:

new public Beta DoSomething() { 
    return BetaFactory.GetBetaFromSomewhere(); 
} 

ma questo non aggiungere la voce dentro al 'vtable', dichiara appena fondamentalmente un metodo nuovo di zecca con lo stesso nome, e come tale significa che l'accesso a Beta attraverso un puntatore a un Alpha chiamerà Alpha.DoSomething().

Quindi, qualche buon trucco?

Answer 1

È possibile fare alcune cose piuttosto strane con i generici.

public class Alpha<T> where T: Alpha<T> { 
    public virtual T DoSomething() { 
     throw new NotImplementedException(); 
    } 
} 
public class Beta : Alpha<Beta> { 
    public override Beta DoSomething() { 
     throw new NotImplementedException(); 
    } 
} 

Answer 2

Perché nella maggior parte dei casi non c'è un grande vantaggio nella covarianza del tipo di ritorno.

Se si chiama virtuale Alpha.DoSomething allora non si sa davvero se si sta recuperando un Alpha o un Beta quindi come può aiutare la covarianza del tipo di ritorno? Dovrai memorizzare il risultato in un oggetto digitato Alpha in ogni caso perché è l'unico tipo che può ammettere Alpha s o Beta s.

D'altra parte, se si sa staticamente che si sta chiamando Beta.DoSomething allora è possibile: utilizzare direttamente il restituita Alpha oggetto tipizzato, perché vi sarà accede comune funzionalità o virtuali metodi in modo da non importa se si tratta di in realtà un Beta (la chiamata virtuale verrà risolta nel tipo giusto) oppure è possibile scegliere direttamente cast (runtime safe) su Beta per accedere all'implementazione specifica.

Modifica: rimosso il problema di tipo sicuro. Ho riflettuto a malapena e, evidentemente, il ritorno della covarianza di tipo sarebbe stato sicuro. Il resto della risposta sta comunque. Non riesco a trovare nulla di particolarmente interessante in questa funzione, almeno nel modo in cui l'OP vuole usarlo: evitare un cast sicuro a basso costo?

Answer 3

Si può sempre avvolgere il metodo all'interno di un altro metodo

public class Alpha { 
    public virtual Alpha DoSomething() { 
     return AlphaFactory.GetAlphaFromSomewhere(); 
    } 
} 
public class Beta : Alpha { 
    private Beta Helper() { 
     return BetaFactory.GetBetaFromSomewhere(); 
    } 
    public Beta DoSomething() { 
     return Helper(); 
    } 
    public override Alpha DoSomething() { 
     return Helper(); 
    } 
} 

Se ci sono un sacco di metodi, però, si potrebbe desiderare di autogenerate questi wrapper. Se è troppo impegnativo, la soluzione di @recursive è tutto ciò che rimane.