C# Génériques Question

Question

Serait-il possible de faire quelque chose comme ce qui suit dans C#? Fondamentalement TParent et TChildren devraient être des types de la classe A mais pas nécessairement avoir les mêmes types qui ont été passés po Je sais que cela peut sembler confus mais je veux taper fortement les enfants et les parents d'un objet particulier, mais à la en même temps, ils doivent être du même type. Comme TParent hérite de A, cela impliquerait qu'il nécessite des paramètres de type héritant de A mais utilisant des types potentiellement différents.

public class A<TParent, TChildren> 
    where TParent : A 
    where TControls : A 
{ 
    TParent Parent; 
    List<TChildren> Children; 
} 

ou plus facilement vu ici:

public class A<TParent, TChildren> 
    where TParent : A<?, ?> 
    where TChildren : A<?, ?> 
{ 
    TParent Parent; 
    List<TChildren> Children; 
} 

J'espère que ce ne soit pas trop confus. Est-ce possible?

Merci :)

Answer 1

Non, ce n'est pas possible. Une solution de contournement, cependant, est de créer une sous-classe de A<TParent, TChild> et d'appliquer que les paramètres de type générique sont de ce type:

public interface A 
{ 
    // some properties and methods 
} 

public class A<TParent, TChild> : A where TParent : A where TChild A 
{ 
    // something else here. 
} 

Answer 2

Si vous essayez de dire « Le parent doit avoir ce type comme un enfant et l'enfant doit avoir ce type en tant que parent » alors je pense que la réponse est non, vous pouvez » t, parce que vous devez également connaître le type du parent du parent et l'enfant de l'enfant.

Cependant, vous pouvez le faire

public interface IHasChildren<T> 
{ 
    List<T> Children { get; set; } 
} 

public interface IHasParent<T> 
{ 
    T Parent { get; set; } 
} 

public class A<TParent, TChildren> : IHasChildren<TChildren>, IHasParent<TParent> 
    where TParent : IHasChildren<A<TParent, TChildren>> 
    where TChildren : IHasParent<A<TParent, TChildren>> 
{ 
    public List<TChildren> Children { get; set; } 
    public TParent Parent { get; set; } 
} 

Answer 3

Non, cela est impossible. Le plus proche vous pouvez venir est de définir un autre type de base, et nécessitent TParent et TChild hériter de ce qui suit:

public class A { } // or an interface 

public class A<TParent, TChild> : A 
    where TParent : A 
    where TChild : A 
{ } 

Ce qui ne vous garantit pas que TParent et TChild sont du type A<,> générique, mais le fait au moins vous permet de leur imposer certaines contraintes que l'implémentation A<,> peut prendre en compte.