La meilleure façon de se référer à mon propre type

Question

abstract class A<T> where T:A<T> 
{ 
    public event Action<T> Event1; 
} 

class B : A<B> 
{ 
    //has a field called Action<B> Event1; 
} 

Y at-il une façon plus élégante de faire cela? Je veux que des choses (événements, etc.) dans la classe de base puissent utiliser le type de la sous-classe.

Answer 1

Le motif que vous utilisez n'implémente pas réellement la contrainte souhaitée. Supposons que vous voulez modéliser « un animal ne peut être amical avec quelque chose de sa propre espèce »:

abstract class Animal<T> where T : Animal<T> 
{ 
    public abstract void GetFriendly(T t); 
} 

class Cat : Animal<Cat> 
{ 
    public override void GetFriendly(Cat cat) {} 
} 

Avons-nous réussi à mettre en œuvre la contrainte souhaitée? Maintenant, un chien maléfique peut être amical avec n'importe quel chat, et pas amical avec d'autres chiens méchants.

La contrainte de type que vous souhaitez n'est pas possible dans le système de type C#. Essayez Haskell si vous avez besoin de ce genre de contrainte appliquée par le système de types.

Voir mon article sur ce sujet pour plus de détails:

http://blogs.msdn.com/b/ericlippert/archive/2011/02/03/curiouser-and-curiouser.aspx

Answer 2

Je ne pense pas que vous deviez spécifier où T: A.

T sera B lorsque vous utilisez la classe B: A

Ceci est également connu sous le nom CRTP or Curiously recurring template pattern et est un idiome connu.

Answer 3

Ce que vous avez fonctionne très bien. En fait, il est très similaire à d'autres interfaces .NET et types où vous voulez que l'implémenteur interface pour utiliser votre type, comme:

public class MyClass : IEqualityComparer<MyClass> 
{ 
    // From the interface IEqualityComparer 
    public bool Equals(MyClass other) { ... } 

    ... 
} 

Answer 4

Puisque A est abstraite, vous pouvez ajouter des méthodes abstraites à A et les invoquerez A et B, qui sera obligé de mettre en œuvre la méthode, sera l'invocateur:

abstract class A<T> where T:A 
{ 
    public event Action<T> Event1; 
    public abstract void Method(); 

    public A(){Method();} 
} 

class B : A<B> 
{ 
    //has a field called Action<B> Event1; 
    public void Method(){ //stuff } 
} 

sur instanciation de B, le constructeur de la classe de base appellera() qui est uniquement mis en œuvre en B, forçant l'instance de B à appeler .

Cela permet à A d'invoquer des méthodes spécifiques à une sous-classe sans que A ait besoin d'avoir des connaissances spécifiques sur les enfants. L'inconvénient est que TOUS les enfants doivent implémenter la Méthode ou la résumer à leurs propres enfants.