通用静态类 - 在运行时检索对象类型

Question

我有一个 X 类型的对象，我可以（显然）在运行时检索它。

var type = myObject.GetType();

我有一个通用的静态类。

public static class MyStaticClass<T>
{
    public static void DoStuff(T something)
    {
        // bla bla
    }
}

我想做的是：

MyStaticClass<myObject.GetType()>.DoStuff(myObject);

但我做不到。

事实上，MyStaticClass 可以操作的类型只有几个，它们共享多个接口。一种解决方法是编写：

if (myObject.GetType() == typeof(X))
{
    MyStaticClass<X>.DoStuff(myObject as X);
}
if (myObject.GetType() == typeof(Y))
{
    MyStaticClass<Y>.DoStuff(myObject as Y);
}

但它很冗长，而且到处都写真的很丑 - 我觉得我不应该这样做，但我也不应该不得不这样做。

我不敢相信没有解决方案。或者至少有任何更整洁的解决方法？或者我的方法一开始是错误的（如果是这样，还有什么选择）？我应该为 X、Y、Z 创建一些（抽象的？）基类吗？

Answer 1

您可以使用反射来做到这一点，使用Type.MakeGenericType - 但是您也需要使用反射来调用该方法。不过这有点痛苦。

如果您使用的是 C# 4，则可以使用动态类型和类型推断 - 尽管这只适用于通用 方法 而不是通用 types，因此您需要使用：

public void DoStuffDynamic(dynamic item)
{
    DoStuffHelper(item);
}

private static void DoStuffHelper<T>(T item)
{
    MyClass<T>.DoStuff(item);
}

编辑：为了性能，您可以避免做太多的实际反射。您可以为每个项目类型执行一次反射一次，创建Action<object> 形式的委托，并将其缓存在字典中。这比在每次执行中执行反射要快远。

这是一个简短但完整的示例：

using System;
using System.Collections.Generic;
using System.Reflection;

public static class MyStaticClass
{
    private static readonly object mapLock = new object();

    private static readonly Dictionary<Type, Action<object>>
        typeActionMap = new Dictionary<Type, Action<object>>();

    private static readonly MethodInfo helperMethod =
        typeof(MyStaticClass).GetMethod("ActionHelper",
                                        BindingFlags.Static |
                                        BindingFlags.NonPublic);

    public static void DoStuffDynamic(object item)
    {
        if (item == null)
        {
            throw new ArgumentNullException("item");
        }

        Type type = item.GetType();
        Action<object> action;
        lock (mapLock)
        {
            if (!typeActionMap.TryGetValue(type, out action))
            {
                action = BuildAction(type);
                typeActionMap[type] = action;
            }
        }
        action(item);
    }

    private static Action<object> BuildAction(Type type)
    {
        MethodInfo generic = helperMethod.MakeGenericMethod(type);
        Delegate d = Delegate.CreateDelegate(typeof(Action<object>),
                                             generic);
        return (Action<object>) d;
    }

    private static void ActionHelper<T>(object item)
    {
        MyStaticClass<T>.DoStuff((T) item);
    }
}


public static class MyStaticClass<T>
{
    public static void DoStuff(T something)
    {
        Console.WriteLine("DoStuff in MyStaticClass<{0}>",
                          typeof(T));
    }
}

public class Test
{
    static void Main()
    {
        MyStaticClass.DoStuffDynamic("Hello");
        MyStaticClass.DoStuffDynamic(10);        
    }
}

我只在我必须时使用这种东西，但偶尔确实没有任何明智的选择。

Answer 2

“实际上，MyStaticClass 可以操作的类型只有几种，它们共享多个接口。一种解决方法是这样写：”

所以你不能针对共享的interface 编写DoStuff 方法吗？这样您就可以针对已知接口进行编程，而不是试图猜测对象是什么类型。整个方法似乎有点狡猾。然后你可以完全删除泛型。

Answer 3

如果没有反射，这是不可能的，泛型类型参数必须在编译时知道。尽管可以通过反思来实现，但我建议不要这样做。你应该改变你的设计。