我有一个通用类:
public class MyList<LinkedItem> : List<LinkedItem> where LinkedItem : MyItem, new()
{
}
从那个泛型类中,我想从 LinkedItem 类访问一个静态函数,它是 MyItem 类的后代。(因此无需创建 LinkedItem 的实例)。
可能吗?
谢谢,
埃里克
我有一个通用类:
public class MyList<LinkedItem> : List<LinkedItem> where LinkedItem : MyItem, new()
{
}
从那个泛型类中,我想从 LinkedItem 类访问一个静态函数,它是 MyItem 类的后代。(因此无需创建 LinkedItem 的实例)。
可能吗?
谢谢,
埃里克
不,这不可能直接从类型参数中进行,因为您不能在泛型类型参数上调用静态方法(C# 语言规范第 4.5 节)。
类型参数不能用于成员访问(第 7.5.4 节)或类型名称(第 3.8 节)来标识静态成员或嵌套类型。
是的,正如其他人所指出的,这可以通过反射技巧来实现。但一般来说,使用反射来解决简单的方法调用场景是糟糕设计的表现。
一个更好的设计是传递一个工厂/委托,它以类型安全的方式封装静态方法。
class MyItem : MyItem {
static void TheFunction() { ... }
}
public class MyList<LinkedItem> : List<LinkedItem> where LinkedItem : MyItem, new()
{
public MyList(Action theStaticFunction) {
...
}
}
new MyList<MyItem>(MyItem.TheFunction);
是的,这是可能的,但是您必须通过从中获取 MethodInfotypeof(T).GetMethod("Foo", BindingFlags.Public | BindingFlags.Static)
然后调用Invoke
它来使用反射。
它非常有用,特别是如果在 ConstructorInfo 而不是 MethodInfo 上使用相同的技术来创建在构造函数中使用参数的通用工厂。它虽然是一个谨慎使用。特别是,在编译时无法保证所讨论的类型具有所需签名的静态方法,因此类型安全性消失了,直到运行时才会捕获此类错误。
它可以通过反射来完成。由于C#对静态成员没有 API 限制,因此没有直接的方法可以做到这一点。
我不确定您所处的场景是什么,但在大多数情况下,这不是推荐的解决方案:)
public class MyList<LinkedItem> : List<LinkedItem>
where LinkedItem : MyItem, new()
{
public int CallStaticMethod()
{
// Getting a static method named "M" from runtime type of LinkedItem
var methodInfo = typeof(LinkedItem)
.GetMethod("M", BindingFlags.Static | BindingFlags.Public);
// Invoking the static method, if the actual method will expect arguments
// they'll be passed in the array instead of empty array
return (int) methodInfo.Invoke(null, new object[0]);
}
}
public class MyItem
{
}
class MyItemImpl : MyItem
{
public MyItemImpl()
{
}
public static int M()
{
return 100;
}
}
因此,例如下一个代码将打印100
:
public void Test()
{
Console.WriteLine(new MyList<MyItemImpl>().CallStaticMethod());
}
这是不可能的。没有办法声明对LinkedItem
参数的约束,说它必须包含有问题的静态方法。
最接近的可能是:
public class ILinkedItemFactory<T>
{
void YourMethodGoesHere();
}
public class MyList<LinkedItem, Factory> : List<LinkedItem>
where Factory : ILinkedItemFactory<LinkedItem>
where LinkedItem : MyItem, new()
{
public MyList(Factory factory)
{
factory.YourMethodGoesHere();
}
}
这是完全可能的,尽管不是直接以您所说的方式进行,而无需反思。您可能希望在基类中实现一个非静态访问方法,并在每个特定的继承类中覆盖它。
public class MyItem
{
public static void DoSomeStaticStuff() { //DoSomeStaticStuff for MyItem }
public virtual void AccessSomeStaticStuff() { MyItem.DoSomeStaticStuff(); }
}
public class SomeItem : MyItem
{
public static void DoSomeStaticStuff() { //DoSomeStaticStuff for SomeItem }
public override void AccessSomeStaticStuff() { SomeItem.DoSomeStaticStuff(); }
}
然后在你的类中具有约束 where T : MyItem 你只需调用 T.AccessSomeStaticStuff();
默认情况下,这是不可能的。但是,如果您知道要调用的方法的名称,并且您肯定每种LinkedItem
类型都将包含此方法,那么您可以使用反射来达到您的目标。注意:对于一般的编程任务,通常有比解决反射更好的方法。
以下将始终输出true
. DoSomething
它调用一个始终可用的静态成员(我删除了您的泛型类型约束,因为这对于静态方法并不重要)。
public class MyList<LinkedItem> : List<LinkedItem>
{
public bool DoSomething()
{
Type t = typeof(LinkedItem);
object o = new Object();
var result = t.InvokeMember("ReferenceEquals",
BindingFlags.InvokeMethod |
BindingFlags.Public |
BindingFlags.Static,
null,
null, new[] { o, o });
return (result as bool?).Value;
}
}
// call it like this:
MyList<string> ml = new MyList<string>();
bool value = ml.DoSomething(); // true
PS:与此同时,当我输入这个时,其他人似乎建议使用相同的方法;-)