ereditarietà generica in C#?

Question

Eventuali duplicati:
Why cannot C# generics derive from one of the generic type parameters like they can in C++ templates?

posso fare

public class MyGenericClass : DL 
//but i cannot do 
public class MyGenericClass <T> : T 

come faccio a fare il secondo? Se non riesco a farlo, come posso fare qualcosa di simile

public class MyGenericClass <T> 
{ 
    T obj; 
    //have all MyGenericClass.XYZ call obj.XYZ 
} 

Answer 1

Questo non è possibile, perché in base alla T tipo è, l'interfaccia pubblica di MyGenericClass cambierebbe.

Se hai un sacco di diverse classi che espongono tutti la stessa interfaccia, si potrebbe dichiarare MyGenericClass per esporre tale interfaccia, e nella realizzazione di tutte le funzioni delegare le chiamate a obj

Answer 2

Si potrebbe fare qualcosa di simile

public interface IXyzable { void xyz(); } 

public class MyGenericClass<T> : IXyzable where T : IXyzable { 
    T obj; 
    public void xyz() { 
     obj.xyz(); 
    } 
} 

Edit: Ora ho capito la domanda

Answer 3

avrai bisogno di tutta la vostra possibile di di attuare alcune interfaccia in modo che si sa che obj.XYZ() ha un senso T, allora si può fare

public interface Ixyz 
{ 
    void XYZ(); 
} 

public class MyGenericClass<T> : Ixyz where T:Ixyz, new() 
{ 
    T obj; 

    public MyGenericClass() 
    { 
     obj = new T(); 
    } 

    public void XYZ() 
    { 
     obj.XYZ(); 
    } 
} 

Ho fatto MyGenericClass implementare Ixyz troppo dal momento che, ovviamente, esporre il metodo giusto, ma forse è meglio lasciare fuori in quanto permette

var x = new MyGenericClass<MyGenericClass<SomeClass>>(); 

che è improbabile che sia mai una buona idea.

Answer 4

Si tratta di una tipica digitazione anatra, ma è possibile utilizzare la riflessione. Quando si crea la classe generica con un riferimento all'oggetto, utilizzare la riflessione per cercare e trovare un metodo con la firma corretta. Finché si memorizza un riferimento al metodo, le prestazioni non saranno eccessive.

class BaseGeneric<T> 
{ 
    private T obj; 
    private MethodInfo mi; 
    private const string MethodNameOfInterest = "Xyz"; 

    public BaseGeneric(T theObject) 
    { 
     this.obj = theObject; 
     Type t = obj.GetType(); 
     mi = t.GetMethod(MethodNameOfInterest); 
    } 

    public void Xyz() 
    { 
     mi.Invoke(obj, null); 
    } 
} 

Naturalmente, si avrebbe bisogno di aggiungere molto di più per il controllo degli errori e così, ma questo è il succo di quello che si potrebbe fare. Inoltre, non dimenticare di aggiungere lo spazio dei nomi System.Reflection alla tua clausola using.

Answer 5

Il sistema di tipo .NET non consente le dichiarazioni di tipo del modulo che si sta tentando. Uno dei motivi per cui ciò non è consentito dovrebbe essere intuitivo: come farebbe MyGenericClass<T> quando T è una classe sigillata (ad esempio System.String)?

Se è assolutamente necessaria questa funzionalità (e si sa che il tipo T da utilizzare non è sigillato), è possibile generare proxy in fase di runtime utilizzando le classi nello spazio dei nomi Reflection.Emit. Potrebbe anche essere possibile ottenere questo effetto utilizzando strumenti AOP come PostSharp.

Answer 6

La domanda specifica, perché non si può fare questo:

public class MyGenericClass<T> : T 

E si può fare questo:

public class MyGenericClass<T> 
{ 
    T obj; 
} 

La ragione è che il CLR piace essere in grado di compilare un singolo versione del codice per MyGenericClass che funzionerà per qualsiasi tipo di riferimento specificato per T.

Può farlo per il secondo caso, perché può tranquillamente sostituire T con object e inserire calchi del caso, più o meno equivalente a:

public class MyGenericClass 
{ 
    object obj; 
} 

Ma per la versione eredità, quel trucco non funziona.

Inoltre, molte strutture utili sarebbero impossibili da descrivere attraverso i vincoli di interfaccia. Quando si eredita da un tipo, si può fare molto di più che chiamare semplicemente i metodi su di esso - è anche possibile sovrascriverli. Considerate questo esempio ipotetico:

class MyBase 
{ 
    public virtual void MyVirtual() { } 
} 

class MyGenericDerived<T> : T 
{ 
    public override void MyVirtual() 
    { 
     Console.WriteLine("Overridden!"); 
    } 
} 

MyBase obj = new MyGenericDerived<MyBase>(); 
obj.MyVirtual(); 

Quello che voglio fare c'è qualcosa come un "mix-in", dove MyGenericDerived fornisce le definizioni per le funzioni virtuali in qualunque base di esso viene applicato. Ma come fa il compilatore a sapere che T avrà un metodo chiamato MyVirtual che può essere sovrascritto? Avrei bisogno di mettere un limite su T. Come potrei esprimerlo attraverso le interfacce? È impossibile. Utilizzare le interfacce per descrivere i vincoli non è una soluzione adeguata una volta che si consente l'ereditarietà dei parametri di tipo. Quindi questa è un'altra ragione per cui oggi non esiste nella lingua.

Answer 7

Che dire di questo:

class BaseClass<T> 
{ 
    public T property { get; set; } 
} 

class GenericClass<T> : BaseClass<T> 
{ 

} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     GenericClass<int> l = new GenericClass<int>(); 
     l.property = 10; 
    } 
} 

questo modo si ottiene ciò che si vuole fare?