我有一个有趣的问题。 我需要动态地封装静态类，即返回一个非静态的实例给我的调用者。 例如，返回一个非静态的实例给我的调用者。
public object CreateInstance(string className) {
Type t = assembly.GetType(className);
if (IsStatic(t)) {
return CreateStaticWrapper(t);
} else {
return Activator.CreateInstance(t);
}
}
所以我需要的是如何实现的指针 CreateStaticWrapper.
注意：很遗憾，我不能使用动态对象。
那么我有什么选择呢？ 我不是很想学习IL生成？ 如果IL生成(Reflection.Emit，或者现在还有其他方法吗?)是我的选择，有谁有这方面的指点吗?
编辑：需要注意的是，我可以返回一个Dictionary of Delegates。 所以我可以使用 Delegate.CreateDelegate 但我似乎不知道如何处理重载方法和Generic方法。
编辑2: 另一个选择是使用Emit注入一个空的构造函数到类型中，同样有指针吗？这在标记为静态的类型上是否可行？static关键字是否能进入IL中？
编辑3：对于一点背景，我把这个传递给javascript环境，请看。 我的项目. 因此，我希望能够（在JavaScript）。
var fileHelper = .create('System.IO.File');
if (fileHelper.Exists(fileName)) { fileHelper.Delete(fileName); }
谢谢大家.
我想说的是去生成IL。创建代理是一个很简单的方案。实际上我写了一篇博客文章来介绍它。einarwh.posterous.compatching-polymorphic-pain-at-runtime.. 场景不同，但解决方案几乎相同。
基本上你可以像博客文章中那样做，除了你不需要将 "this "引用加载到堆栈中（因为你在做静态方法调用）。
试着创建一个继承于 System.Dynamic.DynamicObject. 在包装类中，使用反射来调用静态类的方法。
你需要这样的东西。
public class StaticWrapper<T> : System.Dynamic.DynamicObject
{
private static readonly Type t = typeof(T);
public static int MyProperty { get; set; }
public override bool TryInvokeMember(System.Dynamic.InvokeMemberBinder binder, object[] args, out object result)
{
try
{
result = t.InvokeMember(binder.Name, BindingFlags.Static | BindingFlags.Public, null, null, args);
return true;
}
catch
{
result = null;
return false;
}
}
public override bool TryGetMember(System.Dynamic.GetMemberBinder binder, out object result)
{
try
{
var p = t.GetProperty(binder.Name);
if (p != null)
result = p.GetValue(null, null);
else
{
var f = t.GetField(binder.Name);
if (f != null) result = f.GetValue(null);
else { result = null; return false; }
}
return true;
}
catch
{
result = null;
return false;
}
}
public override bool TrySetMember(System.Dynamic.SetMemberBinder binder, object value)
{
try
{
var p = t.GetProperty(binder.Name);
if (p != null)
p.SetValue(null, value, null);
else
{
var f = t.GetField(binder.Name);
if (f != null) f.SetValue(null, value);
else return false;
}
return true;
}
catch (SystemException)
{
return false;
}
}
}
希望能用得上
所以说，我们玩玩 "Delegate.CreateDelegate "的方式。而后我们再来看看能不能更详细的了解你的其他问题... 我们先说说。
public static object Generate(Type t)
{
if(IsStatic(t))
{
var dictionary = new Dictionary<string, Delegate>();
foreach (var methodInfo in t.GetMethods())
{
var d = Delegate.CreateDelegate(t, methodInfo);
dictionary[methodInfo.Name] = d;
}
return dictionary;
}
return Activator.CreateInstance(t);
}
静态类是 "密封 "的，因此不能被继承。所以我不明白你说的 "重载 "是什么意思。对于通用方法，我们需要调用 methodInfo.MakeGenericMethod(...) 在把它添加到我们的字典里之前。但这样的话，你就需要事先知道类型，我想你是不知道的......。或者，你可以做一些类似的事情。
...
if (methodInfo.IsGenericMethod)
{
d = new Func<MethodInfo, Type[], Delegate>(
(method, types) =>
Delegate.CreateDelegate(
method.DeclaringType, method.MakeGenericMethod(types)));
}
dictionary[methodInfo.Name] = d;
...
这将给你一个委托人，它将接受一个类型数组(通用类型参数)， 并从中产生一个工作委托人。
好吧，我想到的解决方案如下，是通过阅读和研究发现的 Einar的博客文章 他把它作为上面的评论发布。 谢谢艾纳。
但我想我应该把我的 全代码解决方案 在这里，以备将来对别人有所帮助。
using System;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
namespace js.net.jish.Command
{
public class StaticTypeWrapper
{
private readonly Type staticType;
public StaticTypeWrapper(Type staticType)
{
this.staticType = staticType;
}
public object CreateWrapper()
{
string ns = staticType.Assembly.FullName;
ModuleBuilder moduleBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(ns), AssemblyBuilderAccess.Run).DefineDynamicModule(ns);
TypeBuilder wrapperBuilder = moduleBuilder.DefineType(staticType.FullName, TypeAttributes.Public, null, new Type[0]);
foreach (MethodInfo method in staticType.GetMethods().Where(mi => !mi.Name.Equals("GetType")))
{
CreateProxyMethod(wrapperBuilder, method);
}
Type wrapperType = wrapperBuilder.CreateType();
object instance = Activator.CreateInstance(wrapperType);
return instance;
}
private void CreateProxyMethod(TypeBuilder wrapperBuilder, MethodInfo method)
{
var parameters = method.GetParameters();
var methodBuilder = wrapperBuilder.DefineMethod(method.Name, MethodAttributes.Public | MethodAttributes.Virtual, method.ReturnType, parameters.Select(p => p.ParameterType).ToArray());
var gen = methodBuilder.GetILGenerator();
for (int i = 1; i < parameters.Length + 1; i++)
{
gen.Emit(OpCodes.Ldarg, i);
}
gen.Emit(OpCodes.Call, method);
gen.Emit(OpCodes.Ret);
}
}
}