使用反射调用接口方法

Question

我正在使用反射来调用接口方法，并且出现此错误消息“对象引用未设置为对象的实例。”我也尝试使用 ConstructorInfo 并且也有错误。请帮忙。

public class ClassA 
{ 
       private void MethodA(int num, ClassC result)
       {
       } 
}
public interface InterfaceB 
{ 
       ClassC MethodB(int num); 
}
internal class ClassB 
{ 
      public ClassC MethodB(int num)
      {
      } 
}

Type typClassA = Type.GetType("ClassA");
Type typInterfaceB = Type.GetType("InterfaceB");
MethodInfo methodB = typInterfaceB.GetMethod("MethodB", BindingFlags.Public | BindingFlags.Instance); // Error lies here
ClassC result = (ClassC) methodB.Invoke(typInterfaceB, new object[]{num});

MethodInfo methodA = typClassA.GetMethod("MethodA", BindingFlags.NonPublic | BindingFlags.Instance);
methodA.Invoke(typClassA, new object[]{num, result});

ClassB 的实际代码并未声明为“public ClassB : InterfaceB”，而是包含更多类，并且 ClassB 是内部访问。请参阅已编辑的代码。很抱歉多次更改代码，因为我不知道如何简化这种情况。

Answer 1

您必须为 class 提供完全限定的名称。请注意以下示例

namespace ConsoleApplication10
{
    interface IA
    {
        void Print();
    }

    class A : IA
    {
        public void Print()
        {
            Console.WriteLine("Hello");
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            Type type = Type.GetType("ConsoleApplication10.A");
            type.GetMethod("Print").Invoke(Activator.CreateInstance(type, null), null);
        }
    }
}

Answer 2

C#不使用duck-typing。 因此，为了实际实现接口方法，您必须声明您的类实现了该接口：

public class ClassB : InterfaceB

您的代码中还有其他问题：

Type typInterfaceB = Type.GetType("InterfaceB"); // unless you have no namespace at all, you need to specify the fully qualified name

// Probably you got an NRE because of above issue here
MethodInfo methodB = typInterfaceB.GetMethod("MethodB", BindingFlags.Public | BindingFlags.Instance); 

// this does not work, because the first argument needs to be an instance 
// try "new ClassB()" instead
ClassC result = (ClassC) methodB.Invoke(typInterfaceB, new object[]{num});

Answer 3

我不太明白你想要什么，但我认为你需要这样的东西

public interface InterfaceB 
{
    int method(int d);
}
public class ClassB:InterfaceB
{
    int a = 10;
    public int method(int d)
    {
        return a + d;
    }
}


var b = new ClassB();
var mi = typeof(ClassB).GetInterface("InterfaceB").GetMethod("method");
var res = mi.Invoke(b, new object[] { 10 }); // res == 20

更新
又一个变种

public interface InterfaceB 
{
    int method(int d);
}
public class ClassB:InterfaceB
{
    int a = 10;
    public int method(int d)
    {
        return a + d;
    }
}


var b = new ClassB();
var mi = typeof(InterfaceB).GetMethod("method");
var res = mi.Invoke(b, new object[] { 10 }); // res == 20

Answer 4

您正试图在 System.Type 类型的对象上调用方法，而不是在实现该接口的对象上。

MethodInfo.Invoke 的第一个参数是您要在其上调用方法的对象的实例...您使用的是System.Type 对象的实例，而不是ClassA 或ClassB 中的一个实例

Answer 5

你所有的方法都是instance（不是static）方法，所以你必须创建实例来调用它们，并传递这些instances 到Invoke，例如：

  // Let's call MethodA from ClassA

  Object instanceA = new ClassA();
  MethodInfo methodA = instanceA.GetType().GetMethod("MethodA", BindingFlags.NonPublic | BindingFlags.Instance);

  // Pay attention to 1st argument - instanceA
  methodA.Invoke(instanceA, new object[]{num, result});  

  ...

  // Since ClassB doesn't implement InterfaceB, the only option 
  // is to call MethodB of ClassB
  Object instanceB = new ClassB();
  MethodInfo methodB = instanceB.GetType().GetMethod("MethodB", BindingFlags.Public | BindingFlags.Instance);

  ClassC result = (ClassC) (methodB.Invoke(instanceB, new object[]{num}));

Answer 6

如果你确定你的对象有需要的方法，那么你可以使用dynamic 并这样写：

var result = (yourObject as dynamic).YourMethod("SomeParam");

Answer 7

interface IGetNames
{
    string GetFirstName();
    string GetMiddleName();
}
public class GetNames : IGetNames
{
    public string GetFirstName()
    {
        return "First Name";
    }
    public string GetMiddleName()
    {
        return "Middle Name";
    }
}
 static void Main(string[] args)
{
Type _Interface = Type.GetType("ConsoleApplication2.IGetNames");
Type _Class = Type.GetType("ConsoleApplication2.GetNames");
InterfaceMapping GetInterfaceMap = _Class.GetInterfaceMap(_Interface);
MethodInfo methodInfo =  GetInterfaceMap.TargetMethods[0];
object str =  methodInfo.Invoke(Activator.CreateInstance(GetInterfaceMap.TargetType), null);
}