下面是一个代码示例和问题,请注意我不能使用C#4.0和动态关键字。
static class TestClass
{
static void Main(string[] args)
{
Object o = "Previous value";
Test(ref o);
Trace.WriteLine(o);
}
static public void Test<T>(ref T obj)
{
// The goal is to somehow invoke Test2 with the real type of obj, i.e the type in obj.GetType()
// 1st try:
Test2(ref obj); // This doesn't work because the type in Test2 will be the same as T here.
// 2nd try:
MethodInfo mi = typeof(TestClass).GetMethod("Test2");
mi = mi.MakeGenericMethod(new Type[] { obj.GetType() });
mi.Invoke(null, new Object[] { obj }); // obj is no longer by reference so we need to store the object array and copy back the result after the call
// 3rd try, successful implementation by the smartest mind of stack overflow :)
}
static public void Test2<T>(ref T s)
{
if (typeof(T) == typeof(String))
{
s = (T)(Object)"Hello world!";
}
}
}
我还尝试了一些使用Delegate.CreateDelegate但没有任何运气的方法。 这有可能吗?
编辑:我不怕使用动态方法(和MSIL汇编程序),但我在这方面的知识非常有限。
Edit2:这是一个更接近我真正想做的例子:
public static class TypeHandler<T>
{
public delegate void ProcessDelegate(ref T value);
public static readonly ProcessDelegate Process = Init();
private static ProcessDelegate Init()
{
// Do lot's of magic stuff and returns a suitable delegate depending on the type
return null;
}
}
static class TestClass
{
static public void Main(string[] args)
{
Object o = "Previous value";
Test(ref o);
Trace.WriteLine(o);
}
static public void Test<T>(ref T obj)
{
if (obj is T)
{
// Optimized, common case
TypeHandler<T>.Process(ref obj);
return;
}
Type t = obj.GetType();
// How to call the delegate found in TypeHandler<t>.Process ? (I can get delegate but I can't call it).
}
}
答案 0 :(得分:2)
在我看来,主要问题是,你想做什么?
如果您只想将字符串分配给引用对象,可以尝试:
泛型可以在运行时定义,但它不是很舒服,必须通过反思完成......在我看来,这是一个“不行”,而只是一个观点
尝试使用object.GetType()
获取当前的对象类型。
static class TestClass {
static void Main(string[] args) {
Object o = "Previous value";
Test(ref o);
Console.WriteLine(o);
Console.ReadLine();
}
static public void Test<T>(ref T obj) {
Object o = (Object)obj;
Test2(ref o);
obj = (T)o;
}
static public void Test2(ref object s) {
if (s.GetType().Equals(typeof(String))) {
s = "Hello world!";
}
}
}
答案 1 :(得分:2)
您的评论看起来已经了解了如何操作:
MethodInfo mi = typeof(TestClass).GetMethod("Test2");
mi = mi.MakeGenericMethod(new Type[] { obj.GetType() });
object[] args = new object[] { obj };
mi.Invoke(null, args);
obj = (T) args[0];
这真的只是将你的评论转化为代码。那不知道你不想做你想做的事吗?
答案 2 :(得分:1)
更新3 :好的,既然你对丑陋的解决方案很好,你可能想看看the undocumented __refvalue
and __makeref
keywords。
您的问题似乎是您希望能够指定ref object
参数的类型已转换或已更改。
问题在于,您不能随意将任何类型T
的变量分配给string
。因此,您需要传递ref object
或ref string
才能使用 。
我认为oberfreak确定了您要实现的目标(我最初没有注意到您已将o
初始化为string
,因此显然希望其用于影响Test2
函数行为的实际类型。他的回答对你来说是正确的。
更新:您在评论中提到您尝试做的是具有可以使用字典实现的动态行为。我猜这看起来像这样?
更新2 :根据您的更新示例更新此示例。
public static class TypeHandler // note: get rid of generic T parameter
{
delegate void ProcessDelegate(ref object obj); // again, not generic
static Dictionary<Type, ProcessDelegate> processors = new Dictionary<Type, ProcessDelegate>()
{
{ typeof(string), (ref object obj) => { obj = "Hello, world!"; } }
// etc.
};
public static void Process(ref object obj)
{
processors[obj.GetType()].Invoke(ref obj);
}
}
那应该有用。但你无法用泛型实现同样的目标,因为没有办法做到这一点(如你所知):
// not allowed
// |
// -----------
// | |
TypeHandler<o.GetType()>.Process(ref o);
如果是,那么你就会被设置好。但是你能做到这一点的唯一可行方法就是使用反射,对于像这样的东西来说这很难看并且很昂贵,并且显然会打破你保持这种简单并确保良好性能的意图。
答案 3 :(得分:0)
实现方法Test2的正确方法是
static public void Test2<T>(ref T s)
{
if (s is string)
{
s = (T)(Object)"Hello world!";
}
}
或者我在这里遗漏了什么?
答案 4 :(得分:0)
如果您可以将ref
更改为常规回报,则可以通过dynamic
在4.0中大量作弊:
dynamic foo = obj;
Test(foo);
现在是:
Test<TheActualTypeOfObj>(obj);
完整示例:
static void Main(string[] args)
{
object o = "Previous value";
o = Test2((dynamic)o);
Trace.WriteLine(o);
}
static public T Test2<T>(T s)
{
if (typeof(T) == typeof(string))
{
s = (T)(object)"Hello world!";
}
return s;
}
写着“Hello world!”