sentencias - linq notation c#

Llamando al método genérico con un argumento tipo conocido solo en tiempo de ejecución

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo uso el reflejo para llamar a un método genérico? 7 respuestas

Editar:

Por supuesto, mi código real no se ve exactamente así. Traté de escribir semi-pseudocódigo para que fuera más claro de lo que quería hacer.

Parece que simplemente arruinó las cosas en su lugar.

Entonces, lo que realmente me gustaría hacer es esto:

Method<Interface1>();
Method<Interface2>();
Method<Interface3>();
...

Bueno ... pensé que tal vez podría convertirlo en un ciclo utilizando el reflejo. Entonces la pregunta es: ¿Cómo lo hago? Tengo un conocimiento muy superficial de la reflexión. Entonces, los ejemplos de código serían geniales.

El escenario se ve así:

public void Method<T>() where T : class
{}
public void AnotherMethod()
{
Assembly assembly = Assembly.GetExecutingAssembly();
var interfaces = from i in assembly.GetTypes()
where i.Namespace == "MyNamespace.Interface" // only interfaces stored here
select i;
foreach(var i in interfaces)
{
Method<i>(); // Get compile error here!
}

Publicación original:

¡Hola!

Estoy intentando recorrer todas las interfaces en un espacio de nombres y enviarlas como argumentos a un método genérico como este:

public void Method<T>() where T : class
{}
public void AnotherMethod()
{
Assembly assembly = Assembly.GetExecutingAssembly();
var interfaces = from i in assembly.GetTypes()
where i.Namespace == "MyNamespace.Interface" // only interfaces stored here
select i;
foreach(var interface in interfaces)
{
Method<interface>(); // Get compile error here!
}
}

El error que recibo es "Nombre del tipo esperado, pero se encontró el nombre de la variable local". Si intento

...
foreach(var interface in interfaces)
{
Method<interface.MakeGenericType()>(); // Still get compile error here!
}
}

Me aparece "No se puede aplicar el operador ''<'' a los operandos del tipo ''grupo de métodos'' y ''Tipo de sistema''". ¿Alguna idea sobre cómo solucionar este problema?

Answer 1

EDITAR: Bien, es hora de un programa corto pero completo. La respuesta básica es como antes:

• Encuentre el método genérico "abierto" con Type.GetMethod
• Hazlo genérico usando MakeGenericMethod
• Invocarlo con Invoke

Aquí hay un código de muestra. Tenga en cuenta que cambié la expresión de consulta a notación de puntos: no tiene sentido utilizar una expresión de consulta cuando básicamente acaba de obtener una cláusula where.

using System;
using System.Linq;
using System.Reflection;
namespace Interfaces
{
interface IFoo {}
interface IBar {}
interface IBaz {}
}
public class Test
{
public static void CallMe<T>()
{
Console.WriteLine("typeof(T): {0}", typeof(T));
}
static void Main()
{
MethodInfo method = typeof(Test).GetMethod("CallMe");
var types = typeof(Test).Assembly.GetTypes()
.Where(t => t.Namespace == "Interfaces");
foreach (Type type in types)
{
MethodInfo genericMethod = method.MakeGenericMethod(type);
genericMethod.Invoke(null, null); // No target, no arguments
}
}
}

Respuesta original

Dejemos de lado los problemas obvios de llamar a una "interfaz" variable para empezar.

Tienes que llamarlo por reflexión. El objetivo de los genéricos es poner más control de tipos en tiempo de compilación . No sabe cuál es el tipo en tiempo de compilación, por lo tanto, debe usar genéricos.

Obtenga el método genérico y llame a MakeGenericMethod sobre él, luego inícielo.

¿Es tu tipo de interfaz en realidad genérico? Lo pregunto porque está llamando a MakeGenericType, pero no pasa ningún tipo de argumento ... ¿Está tratando de llamar?

Method<MyNamespace.Interface<string>>(); // (Or whatever instead of string)

o

Method<MyNamespace.Interface>();

Si es el último, solo necesita una llamada a MakeGenericMethod - no MakeGenericType.