欲加载组件（它的名称被存储在一个字符串），使用反射来检查它是否具有一个被调用方法“CustomType的MyMethod（字节[]一，INT B）”并调用它或以其他方式抛出异常。 我想我应该做这样的事情，但如果有人可以提供关于如何最好地做同样的建议将不胜感激：
Assembly asm = Assembly.Load("myAssembly"); /* 1. does it matter if write myAssembly or myAssembly.dll? */
Type t = asm.GetType("myAssembly.ClassName");
// specify parameters
byte[] a = GetParamA();
int b = GetParamB();
object[] params = new object[2];
params[0] = a;
params[1] = b;
/* 2. invoke method MyMethod() which returns object "CustomType" - how do I check if it exists? */
/* 3. what's the meaning of 4th parameter (t in this case); MSDN says this is "the Object on which to invoke the specified member", but isn't this already accounted for by using t.InvokeMember()? */
CustomType result = t.InvokeMember("MyMethod", BindingFlags.InvokeMethod, null, t, params);
难道这还不够好，或者有其他更好/更快/更短的方法呢？ 怎么样的构造函数，因为这些方法不是静态的 - 它们可以简单地忽略？
当调用无效（）的方法，是确定只写t.InvokeMember（......），还是应该你老对象OBJ = t.InvokeMember（...）？
提前致谢。
编辑我提供了一个工作示例如下一个单独的答案。
使用反射来检查它是否具有一个称为“CustomType的MyMethod（字节[]一，INT B）”方法并调用它或以其它方式引发异常
您当前的代码不履行这一要求。 但你可以很容易地像这样的东西：
var methodInfo = t.GetMethod("MyMethod", new Type[] { typeof(byte[]), typeof(int) });
if (methodInfo == null) // the method doesn't exist
{
// throw some exception
}
var o = Activator.CreateInstance(t);
var result = methodInfo.Invoke(o, params);
难道这还不够好，或者有其他更好/更快/更短的方法呢？
就我而言，这是最好的办法并没有真的什么每说更快。
怎么样的构造函数，因为这些方法不是静态的 - 它们可以简单地忽略？
你仍然要必须创建的实例t如在我的例子。 这将使用默认的构造函数不带参数。 如果你需要传递的参数就可以了，只看到MSDN文档 ，并修改它是这样。
由于这似乎是一个流行的问题，这里有一个关于如何做到这一点的完整的源代码示例。
假设我们有一个样品装置，MyAssembly.dll程序 ，用MyClass类。 我们要动态加载并调用其方法。 MyAssembly程序代码：
namespace MyAssembly
{
public class MyClass
{
public int X { get; set; }
public int Y { get; set; }
public MyClass(int initialX, int initialY)
{
X = initialX;
Y = initialY;
}
public int MyMethod(int count, string text)
{
Console.WriteLine("This is a normal method.");
Console.WriteLine("Count: {0}", count);
Console.WriteLine("Text: {0}", text);
return this.X + this.Y;
}
public static void StaticMethod(int count, float radius)
{
Console.WriteLine("This is a static method call.");
Console.WriteLine("Count: {0}", count);
Console.WriteLine("Radius: {0}", radius);
}
}
}
首先，我们想创建一个使用构造函数的类的实例MyClass(int initialX, int initialY)然后调用该方法public int MyMethod(int count, string text) 。 这里是你如何从其他项目（如控制台应用程序），这样做：
static void Main(string[] args)
{
//
// 1. Load assembly "MyAssembly.dll" from file path. Specify that we will be using class MyAssembly.MyClass
//
Assembly asm = Assembly.LoadFrom(@"C:\Path\MyAssembly.dll");
Type t = asm.GetType("MyAssembly.MyClass");
//
// 2. We will be invoking a method: 'public int MyMethod(int count, string text)'
//
var methodInfo = t.GetMethod("MyMethod", new Type[] { typeof(int), typeof(string) });
if (methodInfo == null)
{
// never throw generic Exception - replace this with some other exception type
throw new Exception("No such method exists.");
}
//
// 3. Define parameters for class constructor 'MyClass(int initialX, int initialY)'
//
object[] constructorParameters = new object[2];
constructorParameters[0] = 999; // First parameter.
constructorParameters[1] = 2; // Second parameter.
//
// 4. Create instance of MyClass.
//
var o = Activator.CreateInstance(t, constructorParameters);
//
// 5. Specify parameters for the method we will be invoking: 'int MyMethod(int count, string text)'
//
object[] parameters = new object[2];
parameters[0] = 124; // 'count' parameter
parameters[1] = "Some text."; // 'text' parameter
//
// 6. Invoke method 'int MyMethod(int count, string text)'
//
var r = methodInfo.Invoke(o, parameters);
Console.WriteLine(r);
}
调用静态方法public static void StaticMethod(int count, float radius)看起来是这样的：
var methodInfoStatic = t.GetMethod("StaticMethod");
if (methodInfoStatic == null)
{
// never throw generic Exception - replace this with some other exception type
throw new Exception("No such static method exists.");
}
// Specify parameters for static method: 'public static void MyMethod(int count, float radius)'
object[] staticParameters = new object[2];
staticParameters[0] = 10;
staticParameters[1] = 3.14159f;
// Invoke static method
methodInfoStatic.Invoke(o, staticParameters);
Assembly assembly = Assembly.LoadFile("myAssembly");
Type type = assembly.GetType("myAssembly.ClassName");
if (type != null)
{
MethodInfo methodInfo = type.GetMethod("MyMethod");
if (methodInfo != null)
{
object result = null;
ParameterInfo[] parameters = methodInfo.GetParameters();
object classInstance = Activator.CreateInstance(type, null);
if (parameters.Length == 0)
{
//This works fine
result = methodInfo.Invoke(classInstance, null);
}
else
{
object[] parametersArray = new object[] { "Hello" };
//The invoke does NOT work it throws "Object does not match target type"
result = methodInfo.Invoke(classInstance, parametersArray);
}
}
}
您可以使用动态类型，其将在运行时解析。
Type type = Type.GetType(className, true);
dynamic instance = Activator.CreateInstance(type);
var response = instance.YourMethod();
