Cómo conseguir un atributo personalizado de instancia de objeto en C#

Question

Digamos que tengo una clase llamada de prueba con una propiedad llamada Título con un atributo personalizado:

public class Test 
{ 
    [DatabaseField("title")] 
    public string Title { get; set; } 
} 

y un método de extensión llamada DbField. Me pregunto si incluso es posible obtener un atributo personalizado de una instancia de objeto en C#.

Test t = new Test(); 
string fieldName = t.Title.DbField(); 
//fieldName will equal "title", the same name passed into the attribute above 

¿Se puede hacer esto?

Answer 1

Aquí es un enfoque. El método de extensión funciona, pero no es tan fácil. Creo una expresión y luego recupero el atributo personalizado.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Linq.Expressions; 

namespace ConsoleApplication1 
{ 
    public class DatabaseFieldAttribute : Attribute 
    { 
     public string Name { get; set; } 

     public DatabaseFieldAttribute(string name) 
     { 
      this.Name = name; 
     } 
    } 

    public static class MyClassExtensions 
    { 
     public static string DbField<T>(this T obj, Expression<Func<T, string>> value) 
     { 
      var memberExpression = value.Body as MemberExpression; 
      var attr = memberExpression.Member.GetCustomAttributes(typeof(DatabaseFieldAttribute), true); 
      return ((DatabaseFieldAttribute)attr[0]).Name; 
     } 
    } 

    class Program 
    { 
     static void Main(string[] args) 
     { 
      var p = new Program(); 
      Console.WriteLine("DbField = '{0}'", p.DbField(v => v.Title)); 

     } 
     [DatabaseField("title")] 
     public string Title { get; set; } 

    } 
} 

Answer 2

Lo es, pero en última instancia va a ser una forma indirecta, ya que obtendrá la instancia Type de llamar al GetType en su instancia que expone la propiedad, y luego trabajar en eso (la mayoría de las veces).

En este caso específico, su método de extensión no podrá obtener la información del atributo porque todo lo que le está pasando es una cadena.

En última instancia, lo que necesita es algo para obtener el PropertyInfo de la propiedad. Otras respuestas se refieren al Type, lo que les falta es que esta no es la única forma de obtener la información de los atributos en el PropertyInfo que desee.

Usted puede hacer que al hacer pasar una instancia Type con una cadena, presumiblemente, con el nombre de la propiedad, por lo que se puede llamar GetProperty en el Type.

Otra forma de hacer esto ya que C# 3.0 ha sido disponer de un método que toma un Expression<T> y luego usar las partes de la Expression para llegar a la PropertyInfo. En este caso, tomaría un Expression<Func<string>> o algo donde TResult es una cadena.

Una vez que tenga el PropertyInfo, puede llamar al GetCustomAttributes y buscar su atributo.

La ventaja del enfoque de expresión es que Expression<T> deriva de LambdaExpression, que puede llamar al Compile, y luego llamar para obtener el valor real, si lo necesita.

Answer 3

No, no es posible. La razón de esto es que es el valor, y no la propiedad en sí, lo que se enviará a cualquier método de extensión personalizado que obtenga esta información. Una vez que ingresa en ese método de extensión, no hay una forma confiable de rastrear la propiedad.

Podría ser posible for enum values, pero en cuanto a las propiedades en POCO, no va a funcionar.

Answer 4

Para obtener el valor del atributo, necesita el tipo al que se aplica el atributo. Su método de extensión solo obtiene un valor de cadena (el valor de Título), por lo que no podría obtener la instancia real de la que proviene la cadena, y por lo tanto no puede obtener el tipo original al que pertenece la propiedad Título. Esto hará que sea imposible obtener el valor del atributo de su método de extensión.

Answer 5

namespace ConsoleApplication2 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Test t = new Test(); 

      Console.WriteLine(t.FieldName("Title").FieldName<DatabaseFieldAttribute>()); 
      Console.WriteLine(t.FieldName("Title").FieldIsPrimaryKey<DatabaseFieldAttribute>()); 
     } 


    } 

    public class Test 
    { 
     [DatabaseField("titlezzz", true)] 
     public string Title 
     { 
      get; 
      set; 
     } 
    } 


    public class BaseDatabaseFieldAttribute : Attribute 
    { 
     private readonly string _name; 

     public string Name { get { return _name; } } 

     public BaseDatabaseFieldAttribute(string name) 
     { 
      _name = name; 
     } 
    } 
    public class DatabaseFieldAttribute : BaseDatabaseFieldAttribute 
    { 
     private readonly bool _isPrimaryKey; 

     public bool IsPrimaryKey { get { return _isPrimaryKey; } } 

     public DatabaseFieldAttribute(string name, bool isPrimaryKey): base(name) 
     { 
      _isPrimaryKey = isPrimaryKey; 
     } 
    } 

    public static class Helper 
    { 

     public static PropertyInfo FieldName(this object obj, string propertyName) 
     { 
      return obj.GetType().GetProperty(propertyName); 
     } 

     public static string FieldName<T>(this PropertyInfo property) where T: BaseDatabaseFieldAttribute 
     { 
      object[] os = property.GetCustomAttributes(typeof(T), false); 

      if (os != null && os.Length >= 1) 
       return (os[0] as T).Name; 
      else 
       return "N/A"; 
     } 

     public static bool? FieldIsPrimaryKey<T>(this PropertyInfo property) where T : DatabaseFieldAttribute 
     { 
      object[] os = property.GetCustomAttributes(typeof(T), false); 

      if (os != null && os.Length >= 1) 
       return (os[0] as T).IsPrimaryKey; 
      else 
       return null; 
     } 
    } 


} 

Answer 6

Como ya se ha señalado, no es posible con la sintaxis del original cartel descrito, porque no se puede obtener una referencia a PropertyInfo dentro del método de extensión.¿Qué pasa con algo como esto:

// Extension method 
public static string GetDbField(this object obj, string propertyName) 
{ 
    PropertyInfo prop = obj.GetType().GetProperty(propertyName); 
    object[] dbFieldAtts = prop.GetCustomAttributes(typeof(DatabaseFieldAttribute), true); 

    if (dbFieldAtts != null && dbFieldAtts.Length > 0) 
    { 
     return ((DatabaseFieldAttribute)dbFieldAtts[0]).Name; 
    } 

    return "UNDEFINED"; 
} 

A continuación, se pudo obtener información tan simple como:

Test t = new Test(); 
string dbField = t.GetDbField("Title");