c# - property - bindingflags

Excluir propiedad de getType(). GetProperties()

Question

Hola, estoy trabajando en una biblioteca de clases usando C # y tengo algunas clases con algunas propiedades.

Solo quiero saber si puedo agregar algo para excluir algunas propiedades de getType (). GetProperties ().

Un ejemplo de lo que quiero:

prueba de clase

{

   public string one { get; set; }

   public string two {get ; set;}

}

y si hago esto:

estático vacío principal (cadena [] args)

{

  Test t = new Test();

  Type ty = t.GetType();

  PropertyInfo[] pinfo = ty.GetProperties();

  foreach (PropertyInfo p in pinfo)

  {
      Console.WriteLine(p.Name);

  }

}

Quiero que la salida sea algo como esto:

uno

O solo una de las propiedades.

¿Es posible hacer algo así? No sé si hay algún tipo de modificadores o anotaciones en C #, que me permitan hacer lo que quiero.

Gracias.

Answer 1

Con el objeto PropertyInfo puede examinar los atributos GetCustomAttributes de la propiedad. Por lo tanto, podría agregar atributos a sus propiedades cuando los declare, y luego, cuando esté reflexionando sobre las propiedades, puede elegir solo las propiedades que están marcadas con los atributos que desea.

Por supuesto, si realmente desea evitar que alguien obtenga sus propiedades de manera reflexiva, esta no es la solución que desea.

Edición: Siento que quieras GetCustomAttributes, arreglado. Vea esto: http://msdn.microsoft.com/en-us/library/kff8s254.aspx

Answer 2

Los métodos y atributos de extensión te ayudarán a:

public class SkipPropertyAttribute : Attribute
{
}

public static class TypeExtensions
{
    public static PropertyInfo[] GetFilteredProperties(this Type type)
    {
        return type.GetProperties().Where(pi => pi.GetCustomAttributes(typeof(SkipPropertyAttribute), true).Length == 0).ToArray();
    }       
}

public class Test
{
    public string One { get; set; }

    [SkipProperty]
    public string Two { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var t = new Test();
        Type ty = t.GetType();

        PropertyInfo[] pinfo = ty.GetFilteredProperties();
        foreach (PropertyInfo p in pinfo)
        {
            Console.WriteLine(p.Name);
        }

        Console.ReadKey();
    }
}

ACTUALIZAR:

Poco más elegante implementación de las GetFilteredProperties (gracias a Marc Gravell ):

public static class TypeExtensions
{
    public static PropertyInfo[] GetFilteredProperties(this Type type)
    {
        return type.GetProperties().Where(pi => !Attribute.IsDefined(pi, typeof(SkipPropertyAttribute))).ToArray();
    }
}

Answer 3

No creo que puedas hacer esto directamente, pero podrías agregar tus propios atributos personalizados y filtrarlos tú mismo ...

Answer 4

No estoy seguro de cuál es el dominio aquí, así que voy a arriesgarme ...

Por lo general, lo que desea hacer es usar los Attribute s para etiquetar las propiedades que se incluirán en su búsqueda de metadatos, no al revés.

Answer 5

Podrías poner un atributo personalizado en tu tipo.

public class DoNotIncludeAttribute : Attribute
{
}

public static class ExtensionsOfPropertyInfo
{
    public static IEnumerable<T> GetAttributes<T>(this PropertyInfo propertyInfo) where T : Attribute
    {
        return propertyInfo.GetCustomAttributes(typeof(T), true).Cast<T>();
    }
    public static bool IsMarkedWith<T>(this PropertyInfo propertyInfo) where T : Attribute
    {
        return property.GetAttributes<T>().Any();
    }
}
public class Test
{
    public string One { get; set; }

    [DoNotInclude]
    public string Two { get; set; }
}

Luego, en su tiempo de ejecución, puede buscar propiedades que no estén ocultas.

foreach (var property in properties.Where(p => !p.IsMarkedWith<DoNotIncludeAttribute>())
{
    // do something...
}

No se ocultará realmente, pero no se mostrará en la enumeración.