通过使用dynamic
类型而不是反射API,可以大大简化使用仅在运行时知道的类型参数调用通用方法的过程。
要使用此技术,必须从实际对象(不仅仅是Type
类的实例)中知道类型。否则,您必须创建该类型的对象或使用标准的反射API 解决方案。您可以使用Activator.CreateInstance方法创建一个对象。
如果要调用通用方法,则在“常规”用法中会推断出其类型,那么它只是将未知类型的对象强制转换为dynamic
。这是一个例子:
class Alpha { }
class Beta { }
class Service
{
public void Process<T>(T item)
{
Console.WriteLine("item.GetType(): " + item.GetType()
+ "\ttypeof(T): " + typeof(T));
}
}
class Program
{
static void Main(string[] args)
{
var a = new Alpha();
var b = new Beta();
var service = new Service();
service.Process(a); // Same as "service.Process<Alpha>(a)"
service.Process(b); // Same as "service.Process<Beta>(b)"
var objects = new object[] { a, b };
foreach (var o in objects)
{
service.Process(o); // Same as "service.Process<object>(o)"
}
foreach (var o in objects)
{
dynamic dynObj = o;
service.Process(dynObj); // Or write "service.Process((dynamic)o)"
}
}
}
这是该程序的输出:
item.GetType(): Alpha typeof(T): Alpha
item.GetType(): Beta typeof(T): Beta
item.GetType(): Alpha typeof(T): System.Object
item.GetType(): Beta typeof(T): System.Object
item.GetType(): Alpha typeof(T): Alpha
item.GetType(): Beta typeof(T): Beta
Process
是一个泛型实例方法,它写入传递的实GetType()
参的实类型(通过使用该方法)和泛型参数的类型(通过使用typeof
运算符)。
通过将对象参数转换为dynamic
类型,我们推迟提供类型参数,直到运行时。当Process
使用dynamic
参数调用该方法时,编译器将不在乎此参数的类型。编译器生成的代码在运行时检查传递的参数的真实类型(通过使用反射),并选择最佳的调用方法。这里只有一个通用方法,因此可以使用适当的类型参数来调用它。
在此示例中,输出与您编写的相同:
foreach (var o in objects)
{
MethodInfo method = typeof(Service).GetMethod("Process");
MethodInfo generic = method.MakeGenericMethod(o.GetType());
generic.Invoke(service, new object[] { o });
}
具有动态类型的版本肯定更短并且更容易编写。您也不必担心多次调用此函数的性能。借助DLR中的缓存机制,下一次使用相同类型参数的调用应更快。当然,您可以编写代码来缓存调用的委托,但是通过使用dynamic
类型,您可以免费获得此行为。
如果要调用的泛型方法没有参数化类型的参数(因此无法推断其类型参数),则可以将泛型方法的调用包装在帮助器方法中,如以下示例所示:
class Program
{
static void Main(string[] args)
{
object obj = new Alpha();
Helper((dynamic)obj);
}
public static void Helper<T>(T obj)
{
GenericMethod<T>();
}
public static void GenericMethod<T>()
{
Console.WriteLine("GenericMethod<" + typeof(T) + ">");
}
}
增加类型安全性
使用dynamic
对象代替反射API的真正好处是,您只会丢失对这种特定类型的编译时检查,直到运行时才知道。编译器照常静态分析其他参数和方法的名称。如果删除或添加更多参数,更改其类型或重命名方法名称,则会出现编译时错误。如果您在中提供方法名称作为字符串,在中提供Type.GetMethod
参数作为对象数组,则不会发生这种情况MethodInfo.Invoke
。
下面是一个简单的示例,说明了如何在编译时(注释的代码)以及在运行时捕获一些错误。它还显示了DLR如何尝试解析要调用的方法。
interface IItem { }
class FooItem : IItem { }
class BarItem : IItem { }
class Alpha { }
class Program
{
static void Main(string[] args)
{
var objects = new object[] { new FooItem(), new BarItem(), new Alpha() };
for (int i = 0; i < objects.Length; i++)
{
ProcessItem((dynamic)objects[i], "test" + i, i);
//ProcesItm((dynamic)objects[i], "test" + i, i);
//compiler error: The name 'ProcesItm' does not
//exist in the current context
//ProcessItem((dynamic)objects[i], "test" + i);
//error: No overload for method 'ProcessItem' takes 2 arguments
}
}
static string ProcessItem<T>(T item, string text, int number)
where T : IItem
{
Console.WriteLine("Generic ProcessItem<{0}>, text {1}, number:{2}",
typeof(T), text, number);
return "OK";
}
static void ProcessItem(BarItem item, string text, int number)
{
Console.WriteLine("ProcessItem with Bar, " + text + ", " + number);
}
}
在这里,我们通过将参数转换为dynamic
类型来再次执行某种方法。仅对第一个参数类型的验证被推迟到运行时。如果您正在调用的方法的名称不存在,或者其他参数无效(参数数目错误或类型错误),则会出现编译器错误。
当您将dynamic
参数传递给方法时,此调用将被绑定。方法重载解析在运行时发生,并尝试选择最佳重载。因此,如果您ProcessItem
使用BarItem
类型为对象的对象调用该方法,那么您实际上将调用非泛型方法,因为它与该类型更匹配。但是,传递Alpha
类型的参数时会出现运行时错误,因为没有方法可以处理此对象(通用方法具有约束,where T : IItem
而Alpha
类未实现此接口)。但这就是重点。编译器没有此调用有效的信息。作为程序员,您知道这一点,并且应确保该代码运行无误。
返回类型陷阱
当你调用动态类型的参数的非空方法,它的返回类型可能是dynamic
太。因此,如果将先前的示例更改为以下代码:
var result = ProcessItem((dynamic)testObjects[i], "test" + i, i);
那么结果对象的类型将为dynamic
。这是因为编译器并不总是知道将调用哪个方法。如果您知道函数调用的返回类型,则应将其隐式转换为所需的类型,以便其余代码为静态类型:
string result = ProcessItem((dynamic)testObjects[i], "test" + i, i);
如果类型不匹配,则会出现运行时错误。
实际上,如果您尝试在上一个示例中获取结果值,那么您将在第二个循环迭代中遇到运行时错误。这是因为您试图保存void函数的返回值。