C# 调用从封闭泛型继承的methodinfo private static void Main（字符串[]args） { var messageType=typeof（SampleHandler1）； var genericType=typeof（IConsume）。MakeGenericType（messageType）； var genericArguments=genericType.GetGenericArguments（）； var consumerMethod=genericType.GetMethod（“消费”）； var constructorInfo=genericalarguments[0]。GetConstructor（Type.EmptyTypes）； var classObject=constructorInfo.Invoke（新对象[]{}）； var argsx=new object[]{new SampleMessage{Name=“sample message”}； 调用（类对象，argsx）； } 公共接口IConsume，其中T:class { 无效消耗（T消息）； } 公共类SampleHandler1:IConsume { 公共样本处理程序1（） { Debugger.Break（）； } 公共无效使用（SampleMessage消息） { Debugger.Break（）； Console.WriteLine（“消息消费：+Message.Name”）； } } 公共接口iAssembessage { } 公共类SampleMessage:IBaseMessage { 公共字符串名称{get；set；} }

我试着看这里，但我找不到具体的解决办法。正如所解释的

obj 类型：System.Object 要在其上调用方法或构造函数的对象。如果方法是静态的，则忽略此参数。如果构造函数是静态的，则此参数必须为null或定义构造函数的类的实例

---

类对象是构造函数的一个实例，对吗？它抛出异常的原因：

这似乎不正确。让我们分析一下这里发生了什么：

 private static void Main(string[] args)
    {
        var messageType = typeof (SampleHandler1);
        var genericType = typeof (IConsume<>).MakeGenericType(messageType);
        var genericArguments = genericType.GetGenericArguments();
        var consumeMethod = genericType.GetMethod("Consume");

        var constructorInfo = genericArguments[0].GetConstructor(Type.EmptyTypes);
        var classObject = constructorInfo.Invoke(new object[] {});

        var argsx = new object[] {new SampleMessage {Name = "sample message"}};

        consumeMethod.Invoke(classObject, argsx);
    }

public interface IConsume<in T> where T : class
{
    void Consume(T message);
}

public class SampleHandler1 : IConsume<SampleMessage>
{
    public SampleHandler1()
    {
        Debugger.Break();
    }

    public void Consume(SampleMessage message)
    {
        Debugger.Break();
        Console.WriteLine("Message consume: " + message.Name);
    }
}


public interface IBaseMessage
{
}

public class SampleMessage : IBaseMessage
{
    public string Name { get; set; }
}

---

我不确定，但根据您在问题中的所有组件，我怀疑您正在寻找类似的东西：

使用制度

var messageType = typeof(SampleMessage);
var genericType = typeof(IConsume<>).MakeGenericType(messageType);
var consumeMethod = genericType.GetMethod("Consume");

var handlerType = typeof(SampleHandler1);
var constructorInfo = handlerType.GetConstructor(Type.EmptyTypes);
var classObject = constructorInfo.Invoke(new object[] {});

var argsx = new object[] {new SampleMessage {Name = "sample message"}};

consumeMethod.Invoke(classObject, argsx);

还有dotnetfiddle：

---

请记住，这一点都不是类型安全的，但在您的问题中，这似乎不是一个问题。

Ok；在我的理解中是有点不对劲，所以它必须从SampleMessage生成泛型类型，然后从SampleHandler1创建一个类型，然后将参数传递给它。根据我的理解，首先获取SampleHandler1，然后构造类型和调用。我认为您的问题可能缺少一些元素。IBaseMessage是否假定在其上声明了

名称

属性？

var messageType = typeof(SampleMessage);
var genericType = typeof(IConsume<>).MakeGenericType(messageType);
var consumeMethod = genericType.GetMethod("Consume");

var handlerType = typeof(SampleHandler1);
var constructorInfo = handlerType.GetConstructor(Type.EmptyTypes);
var classObject = constructorInfo.Invoke(new object[] {});

var argsx = new object[] {new SampleMessage {Name = "sample message"}};

consumeMethod.Invoke(classObject, argsx);

public class Program
{
    public static void Main()
    {
        var handlerType = typeof (SampleHandler1);
        var genericType = handlerType.GetInterface("IConsume`1");
        var genericArguments = genericType.GetGenericArguments();
        var consumeMethod = genericType.GetMethod("Consume");

        var handlerConstructorInfo = handlerType.GetConstructor(Type.EmptyTypes);
        var handler = handlerConstructorInfo.Invoke(new object[] {});

        var messageConstructorInfo = genericArguments[0].GetConstructor(Type.EmptyTypes);
        var messageObject = messageConstructorInfo.Invoke(new object[] {});

        ((IBaseMessage)messageObject).Name = "Sample Message";

        var argsx = new object[] {messageObject};

        consumeMethod.Invoke(handler, argsx);

    }
}

public interface IConsume<in T> where T : class, IBaseMessage
{
    void Consume(T message);
}

public class SampleHandler1 : IConsume<SampleMessage>
{
    public SampleHandler1()
    {
        Console.WriteLine("SampleHandler1 constructed");
    }

    public void Consume(SampleMessage message)
    {
        Console.WriteLine("Message consume: " + message.Name);
    }
}


public interface IBaseMessage
{
    string Name { get; set; }
}

public class SampleMessage : IBaseMessage
{
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        var handler = new DynamicConstructor(typeof (SampleHandler1)).New();
        invokeIConsumeFor(handler, "Sample Message");
    }

    private static void invokeIConsumeFor(object handler, string message)
    {
        var executer      = new DynamicGenericInterfaceExecuter(handler, "IConsume`1");
        var messageObject = executer.GetTypeArgumentConstructor(0, Type.EmptyTypes).New();

        ((IBaseMessage) messageObject).Name = message;

        executer.Method("Consume", messageObject.GetType()).Call(messageObject);
    }
}

public class DynamicGenericInterfaceExecuter
{
    private object instance;
    private Type genericInterfaceFromType;
    private Type[] genericTypeArguments;
    
    public DynamicGenericInterfaceExecuter(object instance, string interfaceName)
    {
        this.instance                 = instance;
        this.genericInterfaceFromType = instance.GetType().GetInterface(interfaceName);
        this.genericTypeArguments     = this.genericInterfaceFromType.GetGenericArguments();
    }

    public MethodExecuter Method(string methodName, params Type[] parameterTypes)
    {
        return new MethodExecuter(this.instance, this.genericInterfaceFromType, methodName, parameterTypes);
    }

    public DynamicConstructor GetTypeArgumentConstructor(int typeArgumentIndex, params Type[] constructorParameterTypes)
    {
        return new DynamicConstructor(this.genericTypeArguments[typeArgumentIndex], constructorParameterTypes);
    }
}

public class DynamicConstructor
{
    private System.Reflection.ConstructorInfo constructor;

    public DynamicConstructor(Type type, params Type[] constructorParameters)
    {
        this.constructor = type.GetConstructor(constructorParameters);
    }

    public object New(params object[] constructorArguments)
    {
        return this.constructor.Invoke(constructorArguments);
    }
}

public class MethodExecuter
{
    private object instance;
    private System.Reflection.MethodInfo method;

    public MethodExecuter(object instance, Type containerType, string methodName, Type[] methodParameters)
    {
        this.instance = instance;
        this.method   = containerType.GetMethod(methodName, methodParameters);
    }

    public void Call(params object[] arguments)
    {
        this.Invoke(arguments);
    }

    public object Invoke(params object[] arguments)
    {
        return this.method.Invoke(instance, arguments);
    }
}

public interface IConsume<in T> where T : class, IBaseMessage
{
    void Consume(T message);
}

public class SampleHandler1 : IConsume<SampleMessage>
{
    public SampleHandler1()
    {
        Console.WriteLine("SampleHandler1 constructed");
    }

    public void Consume(SampleMessage message)
    {
        Console.WriteLine("Message consume: " + message.Name);
    }
}

public interface IBaseMessage
{
    string Name { get; set; }
}

public class SampleMessage : IBaseMessage
{
    public string Name { get; set; }
}