l'aide des attributs pour les contraintes génériques

Question

donné un exemple, comme ..

public interface IInterface { } 

public static void Insert<T>(this IList<T> list, IList<T> items) where T : IInterface 
{ 
// ... logic 
} 

Cela fonctionne très bien, mais je me demandais s'il est possible d'utiliser un attribut comme une contrainte. Tels que ...

class InsertableAttribute : Attribute 

public static void Insert<T>(this IList<T> list, IList<T> items) where T : [Insertable] 
{ 
// ... logic 
} 

De toute évidence, cette syntaxe ne fonctionne pas, ou je ne serais pas poster la question. Mais je suis juste curieux de savoir si c'est possible ou pas, et comment le faire.

Answer 1

n ° Vous ne pouvez utiliser que des classes (de base) et des interfaces en tant que contraintes.

Vous pouvez cependant faire quelque chose comme ceci:

public static void Insert<T>(this IList<T> list, IList<T> items) 
{ 
    var attributes = typeof(T).GetCustomAttributes(typeof(InsertableAttribute), true); 

    if (attributes.Length == 0) 
     throw new ArgumentException("T does not have attribute InsertableAttribute"); 

    /// Logic. 
} 

Answer 2

Non Vous ne pouvez utiliser des classes, interfaces, class, struct, new(), et d'autres paramètres de type comme des contraintes.

Si InsertableAttribute spécifie [System.AttributeUsage(Inherited=true)], vous pouvez créer une classe fictive comme:

[InsertableAttribute] 
public class HasInsertableAttribute {} 

et limiter votre méthode comme:

public static void Insert<T>(this IList<T> list, IList<T> items) where T : HasInsertableAttribute 
{ 
} 

Alors T aurait toujours l'attribut même si elle était seulement venant de la classe de base. Les classes d'implémentation pourraient "surcharger" cet attribut en le spécifiant sur elles-mêmes.

Answer 3

Non, vous ne pouvez pas. Votre question ne concerne pas les attributs, mais la conception orientée objet. S'il vous plaît lire ce qui suit pour en savoir plus sur generic type constraint.

Je suggère plutôt effectuer les opérations suivantes:

public interface IInsertable { 
    void Insert(); 
} 

public class Customer : IInsertable { 
    public void Insert() { 
     // TODO: Place your code for insertion here... 
    } 
} 

Alors que l'idée est d'avoir une interface IInsertable et implémente cette interface dans une classe chaque fois que vous voulez être insérable. De cette façon, vous restreindrez automatiquement l'insertion pour les éléments insérables.

Il s'agit d'une approche plus flexible, qui vous permettra de conserver des informations identiques ou différentes d'une entité à une autre, car vous devez implémenter l'interface vous-même dans votre classe.