El uso de atributos para las restricciones genéricas

Question

Dado un ejemplo como ..

public interface IInterface { } 

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

Esto funciona bien, pero me preguntaba si es posible utilizar un atributo como una restricción. Tal como ...

class InsertableAttribute : Attribute 

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

Obviamente esta sintaxis no funciona, o no estaría publicando la pregunta. Pero solo tengo curiosidad si es posible o no, y cómo hacerlo.

Answer 1

No. Solo puede usar clases (base) e interfaces como restricciones.

sin embargo, puede hacer algo como esto:

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. Sólo puede utilizar clases, interfaces, class, struct, new() y otros parámetros de tipo como restricciones.

Si InsertableAttribute especifica [System.AttributeUsage(Inherited=true)], entonces se podría crear una clase ficticia como:

[InsertableAttribute] 
public class HasInsertableAttribute {} 

y luego limitar su método como:

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

Entonces T que siempre tendría el atributo aunque fuera solo viene de la clase base. Las clases de implementación podrían "anular" ese atributo al especificarlo en ellos mismos.

Answer 3

No, no puedes. Su pregunta no es sobre atributos, sino un diseño orientado a objetos. Lea lo siguiente para obtener más información sobre generic type constraint.

Prefiero sugiero que haga lo siguiente:

public interface IInsertable { 
    void Insert(); 
} 

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

Así que la idea es tener una interfaz IInsertable, e implementa esta interfaz dentro de una clase cada vez que desee ser insertable. De esta manera, restringirá automáticamente la inserción de elementos insertables.

Este es un enfoque más flexible, y le dará la facilidad de persistir la misma o diferente información de una entidad a otra, ya que tiene que implementar la interfaz usted mismo dentro de su clase.