Les génériques C# peuvent-ils avoir un type de base spécifique?

Question

Est-il possible qu'un type d'interface générique soit basé sur une classe parent spécifique?

Par exemple:

public interface IGenericFace<T : BaseClass> 
{ 
} 

Il est évident que le code ci-dessus ne fonctionne pas, mais si elle l'a fait, ce que je suis en train de dire au compilateur est que T doit être une sous-classe de BaseClass. Cela peut-il être fait, y a-t-il des plans, etc.?

Je pense qu'il serait utile en termes d'un projet spécifique, en s'assurant qu'une interface/classe générique n'est pas utilisée avec des types non intentionnels au moment de la compilation. Ou encore, sorte de self-document: montrez quel type de type est prévu.

Answer 1

public interface IGenericFace<T> where T : SomeBaseClass 

Answer 2

oui.

public interface IGenericFace<T> 
    where T : BaseClass 
{ 
} 

Answer 3

Plus d'informations sur les interfaces génériques: http://msdn.microsoft.com/en-us/library/kwtft8ak(VS.80).aspx

Answer 4

Ce que votre parlez est appelé "Contraintes génériques". De nombreuses contraintes peuvent être imposées sur un type générique.

Quelques exemples de base sont les suivantes:

• where T: struct - L'argument de type doit être un type de valeur. Tout type de valeur sauf Nullable - peut être spécifié. Voir Using Nullable Types (C# Programming Guide) pour plus d'informations.

• where T : class - L'argument type doit être un type de référence; Cela s'applique également à tout type de classe, d'interface, de délégué ou de tableau.

• where T : new() - L'argument type doit avoir un constructeur public sans paramètre. Lorsqu'elle est utilisée avec d'autres contraintes, la contrainte new() doit être spécifiée en dernier.

• where T : <base class name> - L'argument type doit être dérivé de la classe de base spécifiée.

• where T : <interface name> - L'argument type doit être ou implémenter l'interface spécifiée. Des contraintes d'interface multiples peuvent être spécifiées. L'interface contraignante peut également être générique. - L'argument type fourni pour T doit être dérivé de l'argument fourni pour U. C'est ce qu'on appelle une contrainte de type nu.

Ceux-ci peuvent également être reliés entre eux comme ceci:

C#

public class TestClass<T> where T : MyBaseClass, INotifyPropertyChanged, new() { } 
public interface IGenericFace<T> where T : SomeBaseClass 

VB

Public Class TestClass(Of T As {MyBaseClass, INotifyPropertyChanged, New}) 
Public Interface IGenericInterface(Of T As SomeBaseClass)