c# - que - ¿Cómo puedo agregar un método de extensión a muchas clases?

que es override en c#

Question

Tengo alrededor de 1000 clases en las que necesito contar el número de propiedades de. Tengo el siguiente código:

    public static int NumberOfProperties()
    {
        Type type = typeof(C507);
        return type.GetProperties().Count();
    }

Podría copiar y pegar esto en cada clase cambiando el parámetro typeof , pero esto parece un poco tedioso.

¿Hay alguna forma de hacer un método de extensiones para hacer esto simplemente haciendo var nop = C507.NumberOfProperties(); ?

Answer 1

Entonces puede escribir un método de extensión que use un objeto o uno que use tipo.

public static class ObjectExtensions
{
    public static int GetNumberOfProperties(this object value)
    {
        return value.GetType().GetProperties().Count();
    }

    public static int GetNumberOfProperties(this Type value)
    {
        return value.GetProperties().Count();
    }
}

Uso:

new C507().GetNumberOfProperties();
typeof(C507).GetNumberOfProperties();

Sin embargo, declaras explícitamente dos cosas :

Podría copiar y pegar esto en cada clase cambiando el tipo de

Tengo alrededor de 1000 clases

Es probable que no desee crear instancias de 1000 clases o copiar y pegar typeof() 1000 veces

En este caso, querrá leerlos todos de la Asamblea.

Entonces algo así como:

typeof(SomeClass).Assembly.GetTypes().Select(x => new
  {
       x.Name, 
       PropertyCount = x.GetType().GetProperties().Count()
  });

Donde SomeClass es una clase (no importa cuál) donde residen todas las clases.

Simplemente los selecciono en un objeto anónimo que contiene el nombre de Tipos y el recuento de propiedades.

Esta:

typeof(SomeClass).Assembly

Es solo una forma conveniente de obtener el ensamblaje. Hay otras formas.

Assembly.GetAssembly(typeof(Program)).GetTypes()
Assembly.GetCallingAssembly().GetTypes()
Assembly.Load("Some Assemble Ref").GetTypes()

Puede hacer todos los tipos con los tipos que encuentre. Si selecciona el Type sí mismo, puede crear una instancia más tarde usando Activator.CreateInstance (si tiene constuctor sin parámetros). También puede autocompletar las propiedades con reflexión también.

Answer 2

Es imposible tener un método de extensión estático como lo imaginas. Dicho esto, sería posible crear un método genérico en una clase auxiliar de la siguiente manera.

public static int NumberOfProperties<T>()
{
    Type type = typeof(T);
    return type.GetProperties().Count();
}

Dado un tipo SomeType podría llamarse como int n = NumberOfProperties<SomeType>() .

Answer 3

Hay un par de formas de hacer esto que son variaciones de la misma cosa.

Puede pasar el Tipo como argumento a un método:

public static class Helper {
    public static int NumberOfProperties(Type type)
    {
        return type.GetProperties().Count();
    }
}

Que llamarías así:

// Imagine you have a class called MyClass
var result = Helper.NumberOfProperties(typeof(MyClass));

Utiliza el sistema genérico en C # para hacer que la sintaxis sea un poco más limpia. Eso se vería así:

public static class Helper {
    // Notice the argument was removed and 
    // the use of the "generic" syntax <T>
    public static int NumberOfProperties<T>()
    {
        var type = typeof(T);
        return type.GetProperties().Count();
    }
}

Y lo llamarías así:

var result = Helper.NumberOfProperties<MyClass>();

También puede usar "Extensiones" que le permiten llamarlo como si fuera un método que pertenecía a sus clases.

public static class Helper {
    // notice the `this` keyword before the parameter 
    // this is what tells C# that this is an extension method
    public static int NumberOfProperties<T>(this T @this)
    {
        var type = typeof(T);
        return type.GetProperties().Count();
    }
}

Esto le permitirá llamar al método de esta manera:

 var instance = new MyClass();
 var result = instance.NumberOfProperties();

En este ejemplo, utilicé la sintaxis genérica para que se aplique a cualquier tipo de objeto. Si quisiera limitarlo solo a los objetos que heredan de una interfaz o clase base específica, simplemente lo cambiaría de usar la sintaxis genérica a usar la clase / interfaz base. Me gusta esto:

public static class Helper {
    // notice the type got changed from a generic <T>
    // to specifying the exact class you want to "extend"
    public static int NumberOfProperties(this MyBaseClass @this)
    {
        var type = typeof(T);
        return type.GetProperties().Count();
    }
}

Como mencionó @ rené-vogt, también puede crear el método de extensión para que amplíe el tipo Type lugar. Ver su respuesta en este hilo: https://.com/a/38455233/984780

Answer 4

Podría hacer un método de extensión en un object como este:

public static int PropertyCount(this object thing)
{
    return thing.GetType().GetProperties().Count();
}

Y úsalo en cualquier objeto que te guste:

var x = "some string";
var numProps = x.PropertyCount();

Answer 5

Puede hacer un método de extensión genérico que se puede aplicar a todos los tipos:

public static int PropertyCount<T>(this T obj)
{
    return typeof(T).GetProperties().Length;
}

Esto se aplicará a todos los tipos, incluidos los tipos de valores (estructuras de IE) que no se aplicarán a los objetos. Gracias a piedar por señalar mi error aquí, aplicar al objeto todavía agrega este método de extensión a los tipos de valor.

Answer 6

Si quieres tener un método de extensión en el object :

public static ObjectExtensions
{
    public static int NumberOfProperties(this object value)
    {
        if (null == value)
          throw new ArgumentNullException("value"); // or return 0

        // Length: no need in Linq here
        return value.GetType().GetProperties().Length;
    }
}

...

C507 myObj = new C507();

// How many properties does myObj instance have?
int propCount = myObj.NumberOfProperties(); 

Si desea tener un método extesnion en Type :

   public static TypeExtensions
    {
        public static int NumberOfProperties(this Type value)
        {
            if (null == value)
              throw new ArgumentNullException("value"); // or return 0

            // Length: no need in Linq here
            return value.GetProperties().Length;
        }
    }

    ...


    // How many properties does C507 type have?
    int propCount = typeof(C507).NumberOfProperties(); 

Answer 7

Si su clase puede implementar una interfaz, puede extender esa interfaz.

public interface IExtensible {
}

class C507 : IExtensible {

}

public static int NumberOfProperties(this IExtensible extensible)
{
    Type type = extensible.GetType();
    return type.GetProperties().Count();
}

Dicho esto, tener cientos de clases (¿generado?) Parece una mala solución para empezar.

Answer 8

Solo para agregar a las respuestas que sugieren una extensión para que el object esté completo: también puede considerar implementar una extensión solo para Type :

public static int GetPropertyCount(this Type t)
{
    return t.GetProperties().Length;
}

y úsalo así:

typeof(C507).GetPropertyCount();

La ventaja es que puedes obtener el número de propiedades directamente del tipo y no tienes que crear una instancia primero.