utilizzando attributi per i vincoli generici

Question

dato l'esempio, come ..

public interface IInterface { } 

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

Questo funziona bene, ma mi chiedevo se è possibile utilizzare un attributo come un vincolo. Ad esempio ...

class InsertableAttribute : Attribute 

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

Ovviamente questa sintassi non funziona, o non vorrei postare la domanda. Ma sono curioso di sapere se è possibile o meno, e come farlo.

Answer 1

No. È possibile utilizzare solo classi e interfacce (base) come vincoli.

È possibile comunque fare qualcosa di simile:

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

No. È possibile utilizzare solo le classi, interfacce, class, struct, new(), e altri parametri di tipo come vincoli.

Se InsertableAttribute specifica [System.AttributeUsage(Inherited=true)], allora si potrebbe creare una classe fittizia come:

[InsertableAttribute] 
public class HasInsertableAttribute {} 

e quindi limitare il vostro metodo come:

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

Poi T avrebbe sempre l'attributo anche se è stato proveniente solo dalla classe base. Le classi di implementazione sarebbero in grado di "scavalcare" quell'attributo specificandolo su se stessi.

Answer 3

No, non è possibile. La tua domanda non riguarda gli attributi, ma il design orientato agli oggetti. Si prega di leggere quanto segue per ulteriori informazioni su generic type constraint.

Io invece consiglio di fare quanto segue:

public interface IInsertable { 
    void Insert(); 
} 

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

Così che l'idea è quella di avere un'interfaccia IInsertable, e implementa questa interfaccia all'interno di una classe ogni volta che si desidera essere inseribile. In questo modo, si limiterà automaticamente l'inserimento per elementi inseribili.

Questo è un approccio più flessibile e ti darà la facilità di mantenere qualsiasi informazione uguale o diversa da un'entità a un'altra, poiché devi implementare l'interfaccia tu stesso all'interno della classe.