Metodo astratto che restituisce un'istanza della classe derivata

Question

È possibile creare un metodo astratto che deve restituire un'istanza della classe derivata? Posso fare questo:

abstract class Base 
{ 
    public abstract Base GetObj(); 
} 

class Derived : Base 
{ 
    public Derived() { } 

    public override Base GetObj() 
    { 
     return new Derived(); 
    } 
} 

ma mi chiedevo se ci fosse un modo per farlo in modo tale che Derived::GetObj() è costretto a restituire un Derived?

Grazie.

Answer 1

Utilizzando farmaci generici dovrebbe rendere questo possibile:

abstract class Base<T> 
    where T : Base<T> 
{ 
    public abstract T GetObj(); 
} 

class Derived : Base <Derived> 
{ 
    public Derived() { } 

    public override Derived GetObj() 
    { 
     return new Derived(); 
    } 
} 

si potrebbe anche semplificare questo ancora di più (se tutte le istanze derivati ​​vengono creati con i costruttori di default):

abstract class Base<T> 
    where T : Base<T>, new() 
{ 
    public static T GetObj() 
    { 
     return new T(); 
    } 
} 

class Derived : Base<Derived> 
{ 
    public Derived() { } 
} 

Answer 2

quello che hai è quasi, ma non esattamente, una fabbrica astratta. Prima dirò che dovresti lasciarlo agli implementatori delle classi derivate per farlo bene, o semplicemente fidarti che lo faranno.

Un'altra risposta ha mostrato quello che è noto come il modello di modello con ricorrenza curiosa dello . È qui che si ha una classe base che tenta di utilizzare il sistema di tipi per far sì che i tipi derivati ​​si usino in determinate posizioni di input o di output.

public abstract class Foo<T> where T : Foo<T> 
public class Bar : Foo<Bar> 

Questa idea potrebbe funzionare in altre lingue. Funziona solo in C# fino a quando le persone lo usano correttamente. Con la definizione sopra di Bar, ora posso anche avere

public class Baz : Foo<Bar> 

Che è perfettamente legale. Bar è un Foo<Bar>, che è tutto ciò che è necessario per Baz per usarlo. Nulla richiede che Baz utilizzi effettivamente lo Foo<Baz>.

Il sistema di tipi in C# non può semplicemente imporre ciò che si desidera applicare. Anche con questo modello in posizione, sei ancora nella stessa posizione di prima. Devi ancora fidarti degli implementatori delle classi derivate per farlo correttamente.

Per ulteriori informazioni su questo argomento, è possibile leggere this blog.