在编译时不知道type参数时调用泛型方法的最佳方法是什么,而是在运行时动态获取?
考虑以下示例代码 - 在Example()
方法中,使用GenericMethod<T>()
变量中存储的Type
来调用myType
的最简洁方法是什么?
public class Sample
{
public void Example(string typeName)
{
Type myType = FindType(typeName);
// What goes here to call GenericMethod<T>()?
GenericMethod<myType>(); // This doesn't work
// What changes to call StaticMethod<T>()?
Sample.StaticMethod<myType>(); // This also doesn't work
}
public void GenericMethod<T>()
{
// ...
}
public static void StaticMethod<T>()
{
//...
}
}
答案 0 :(得分:1035)
您需要使用反射来启动方法,然后通过使用MakeGenericMethod提供类型参数来“构造”它:
MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);
对于静态方法,将null
作为Invoke
的第一个参数传递。这与通用方法无关 - 它只是正常反射。
如上所述,使用dynamic
的C#4中的很多内容更简单 - 当然,如果你可以使用类型推断。如果类型推断不可用,例如问题中的确切示例,则无效。
答案 1 :(得分:151)
只是对原始答案的补充。虽然这会奏效:
MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);
这也有点危险,因为你失去了GenericMethod
的编译时检查。如果您稍后进行重构并重命名GenericMethod
,则此代码将不会注意到,并且会在运行时失败。此外,如果对程序集进行任何后处理(例如,混淆或删除未使用的方法/类),则此代码也可能会中断。
所以,如果你知道你在编译时链接到的方法,并且没有调用数百万次,那么开销无关紧要,我会将此代码更改为:
Action<> GenMethod = GenericMethod<int>; //change int by any base type
//accepted by GenericMethod
MethodInfo method = this.GetType().GetMethod(GenMethod.Method.Name);
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);
虽然不是很漂亮,但你在这里有GenericMethod
的编译时引用,如果你重构,删除或对GenericMethod
做任何事情,这段代码将继续工作,或者至少在编译时中断时间(例如,如果删除GenericMethod
)。
执行相同操作的其他方法是创建一个新的包装类,并通过Activator
创建它。我不知道是否有更好的方法。
答案 2 :(得分:125)
使用dynamic
类型而不是反射API,可以大大简化使用仅在运行时知道的类型参数调用泛型方法。
要使用此技术,必须从实际对象(不仅仅是Type
类的实例)中获知类型。否则,您必须创建该类型的对象或使用标准反射API solution。您可以使用Activator.CreateInstance方法创建对象。
如果你想调用泛型方法,那么在&#34; normal&#34;用法会推断出它的类型,然后它只是将未知类型的对象转换为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
运算符)
通过将object参数转换为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中的caching机制,具有相同类型参数的下一个调用应该更快。当然,您可以编写缓存调用的委托的代码,但是使用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
参数传递给方法时,此调用为lately bound。方法重载解析在运行时发生并尝试选择最佳过载。因此,如果您使用ProcessItem
类型的对象调用BarItem
方法,那么您实际上会调用非泛型方法,因为它更适合此类型。但是,当您传递Alpha
类型的参数时,您将收到运行时错误,因为没有可以处理此对象的方法(泛型方法具有约束where T : IItem
和Alpha
类没有实现此接口)。但这就是重点。编译器没有此调用有效的信息。作为程序员你知道这一点,你应该确保这段代码运行没有错误。
当您使用动态类型参数调用非void方法时,其返回类型可能为be dynamic
too。因此,如果您将以前的示例更改为此代码:
var result = ProcessItem((dynamic)testObjects[i], "test" + i, i);
然后结果对象的类型为dynamic
。这是因为编译器并不总是知道将调用哪个方法。如果你知道函数调用的返回类型,那么你应该implicitly convert它到所需的类型,所以其余的代码是静态类型的:
string result = ProcessItem((dynamic)testObjects[i], "test" + i, i);
如果类型不匹配,您将收到运行时错误。
实际上,如果您尝试在前面的示例中获取结果值,那么您将在第二次循环迭代中获得运行时错误。这是因为您试图保存void函数的返回值。
答案 3 :(得分:16)
使用C#4.0,不需要反射,因为DLR可以使用运行时类型调用它。由于使用DLR库是一种动态的痛苦(而不是为您生成代码的C#编译器),开源框架Dynamitey(.net标准1.5)为您提供了对相同调用的轻松缓存运行时访问编译器会为你生成。
var name = InvokeMemberName.Create;
Dynamic.InvokeMemberAction(this, name("GenericMethod", new[]{myType}));
var staticContext = InvokeContext.CreateStatic;
Dynamic.InvokeMemberAction(staticContext(typeof(Sample)), name("StaticMethod", new[]{myType}));
答案 4 :(得分:10)
从类型信息调用泛型方法涉及三个步骤。
((Action)GenericMethod<object>)
.Method
.GetGenericMethodDefinition()
.MakeGenericMethod(typeof(string))
.Invoke(this, null);
其中GenericMethod<object>
是要调用的方法名称以及满足通用约束的任何类型。
(Action)匹配要调用的方法的签名,即(Func<string,string,int>
或Action<bool>
)
MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
从包含方法的类内部开始:
MethodInfo method = ((Action)GenericMethod<object>)
.Method
.GetGenericMethodDefinition();
MethodInfo method = ((Action)StaticMethod<object>)
.Method
.GetGenericMethodDefinition();
来自包含方法的类的外部:
MethodInfo method = ((Action)(new Sample())
.GenericMethod<object>)
.Method
.GetGenericMethodDefinition();
MethodInfo method = ((Action)Sample.StaticMethod<object>)
.Method
.GetGenericMethodDefinition();
在C#中,方法的名称,即“ToString”或“GenericMethod”实际上是指可以包含一个或多个方法的一组方法。在提供方法参数的类型之前,不知道哪个 你指的方法。
((Action)GenericMethod<object>)
指的是特定方法的委托。 ((Func<string, int>)GenericMethod<object>)
指的是GenericMethod
MethodInfo method = ((MethodCallExpression)((Expression<Action<Sample>>)(
(Sample v) => v.GenericMethod<object>()
)).Body).Method.GetGenericMethodDefinition();
这分解为
创建一个lambda表达式,其中正文是对所需方法的调用。
Expression<Action<Sample>> expr = (Sample v) => v.GenericMethod<object>();
提取正文并转换为MethodCallExpression
MethodCallExpression methodCallExpr = (MethodCallExpression)expr.Body;
从方法
获取通用方法定义MethodInfo methodA = methodCallExpr.Method.GetGenericMethodDefinition();
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);
答案 5 :(得分:5)
没有人提供&#34; 经典反思&#34;解决方案,所以这是一个完整的代码示例:
using System;
using System.Collections;
using System.Collections.Generic;
namespace DictionaryRuntime
{
public class DynamicDictionaryFactory
{
/// <summary>
/// Factory to create dynamically a generic Dictionary.
/// </summary>
public IDictionary CreateDynamicGenericInstance(Type keyType, Type valueType)
{
//Creating the Dictionary.
Type typeDict = typeof(Dictionary<,>);
//Creating KeyValue Type for Dictionary.
Type[] typeArgs = { keyType, valueType };
//Passing the Type and create Dictionary Type.
Type genericType = typeDict.MakeGenericType(typeArgs);
//Creating Instance for Dictionary<K,T>.
IDictionary d = Activator.CreateInstance(genericType) as IDictionary;
return d;
}
}
}
上面的DynamicDictionaryFactory
类有一个方法
CreateDynamicGenericInstance(Type keyType, Type valueType)
它创建并返回一个IDictionary实例,其键和值的类型与调用keyType
和valueType
中指定的完全一致。
以下是一个完整的示例如何调用此方法来实例化并使用Dictionary<String, int>
:
using System;
using System.Collections.Generic;
namespace DynamicDictionary
{
class Test
{
static void Main(string[] args)
{
var factory = new DictionaryRuntime.DynamicDictionaryFactory();
var dict = factory.CreateDynamicGenericInstance(typeof(String), typeof(int));
var typedDict = dict as Dictionary<String, int>;
if (typedDict != null)
{
Console.WriteLine("Dictionary<String, int>");
typedDict.Add("One", 1);
typedDict.Add("Two", 2);
typedDict.Add("Three", 3);
foreach(var kvp in typedDict)
{
Console.WriteLine("\"" + kvp.Key + "\": " + kvp.Value);
}
}
else
Console.WriteLine("null");
}
}
}
执行上述控制台应用程序时,我们会得到正确的预期结果:
Dictionary<String, int>
"One": 1
"Two": 2
"Three": 3
答案 6 :(得分:2)
这是基于Grax's answer的2美分,但通用方法需要两个参数。
假设您的方法在Helpers类中定义如下:
public class Helpers
{
public static U ConvertCsvDataToCollection<U, T>(string csvData)
where U : ObservableCollection<T>
{
//transform code here
}
}
在我的例子中,U type总是一个可观察的集合,存储类型为T的对象。
由于我预先定义了我的类型,我首先创建&#34; dummy&#34;表示可观察集合(U)和存储在其中的对象(T)的对象,下面将使用这些对象在调用Make时获取其类型
object myCollection = Activator.CreateInstance(collectionType);
object myoObject = Activator.CreateInstance(objectType);
然后调用GetMethod找到你的通用函数:
MethodInfo method = typeof(Helpers).
GetMethod("ConvertCsvDataToCollection");
到目前为止,上述调用与上面解释的内容完全相同,但是当您需要将多个参数传递给它时,差异很小。
您需要将Type []数组传递给MakeGenericMethod函数,该函数包含&#34; dummy&#34;对象&#39;上面创建的类型:
MethodInfo generic = method.MakeGenericMethod(
new Type[] {
myCollection.GetType(),
myObject.GetType()
});
完成后,您需要调用上面提到的Invoke方法。
generic.Invoke(null, new object[] { csvData });
你已经完成了。有魅力!
<强>更新强>
正如@Bevan强调的那样,我不需要在调用MakeGenericMethod函数时创建一个数组,因为它接受params并且我不需要创建一个对象来获取类型,因为我可以直接将类型传递给这个功能。就我而言,由于我在另一个类中预定义了类型,我只需将代码更改为:
object myCollection = null;
MethodInfo method = typeof(Helpers).
GetMethod("ConvertCsvDataToCollection");
MethodInfo generic = method.MakeGenericMethod(
myClassInfo.CollectionType,
myClassInfo.ObjectType
);
myCollection = generic.Invoke(null, new object[] { csvData });
myClassInfo包含2个Type
类型的属性,我在运行时根据传递给构造函数的枚举值设置这些属性,并将为我提供我在MakeGenericMethod中使用的相关类型。
再次感谢您突出显示@Bevan。
答案 7 :(得分:0)
受Enigmativity's answer的启发-假设您有两个(或更多)类,例如
public class Bar { }
public class Square { }
,您想使用Foo<T>
和Bar
调用方法Square
,该方法声明为
public class myClass
{
public void Foo<T>(T item)
{
Console.WriteLine(typeof(T).Name);
}
}
然后,您可以实现 Extension方法,例如:
public static class Extension
{
public static void InvokeFoo<T>(this T t)
{
var fooMethod = typeof(myClass).GetMethod("Foo");
var tType = typeof(T);
var fooTMethod = fooMethod.MakeGenericMethod(new[] { tType });
fooTMethod.Invoke(new myClass(), new object[] { t });
}
}
这样,您可以像这样简单地调用Foo
:
var objSquare = new Square();
objSquare.InvokeFoo();
var objBar = new Bar();
objBar.InvokeFoo();
适用于所有课程。在这种情况下,它将输出:
平方
吧