C# 传递泛型参数会导致调用错误的重载

我正在尝试更新，以允许装饰过的POCO在其当前使用的任何位置使用

列表

。我遇到的问题是调用了错误的重载。下面是我看到的一个简单例子：

void Run()
{
    CallDoSomething<Program>("Hello World", new object());
    CallDoSomething<Program>("Hello World2", new List<int>());
}

// `DoSomething<T>` represents the functions that do the heavy lifting
public T DoSomething<T>(string someString, List<int> ints) where T : class
{
    Console.WriteLine("List<int>: {0}", someString);
    return default(T);
}
public T DoSomething<T>(string someString, object ints) where T : class
{
    Console.WriteLine("object: {0}", someString);
    // In my real implementation, this turns the object to a typed List<T>
    // and passes it to the previous overload.
    return default(T);
}

// We're trying to refactor the code in this method to reduce code duplication in
// the `CallDoSomething<T>` methods that will actually be called by the end user
internal T CallDoSomething<T, U>(string someString, U ints) where T : class
{
    // Do a bunch of stuff here that would otherwise be duplicated by the `CallDoSomething<T>` methods
    return DoSomething<T>(someString, ints);
}

public T CallDoSomething<T>(string someString, List<int> ints) where T : class
{
    return CallDoSomething<T, List<int>>(someString, ints);
}
public T CallDoSomething<T>(string someString, object ints) where T : class
{
    return CallDoSomething<T, object>(someString, ints);
}

当我期待它是：

object: Hello World
List<int>: HelloWorld2

---

这似乎是可行的，它消除了大量的代码重复，但它使代码相当复杂。有更好的方法解决这个问题吗？

是的，重载在编译时解决。如果使用C#4，可以强制在执行时对其求值，如下所示：

internal T CallDoSomething<T, U>(string someString, U ints) where T : class
{
    dynamic d = ints;
    return DoSomething<T>(someString, d);
}

internalt-CallDoSomething（string-someString，U-int），其中T:class
{
动态d=整数；
返回DoSomething（someString，d）；
}

---

然而，就我个人而言，如果你可能的话，我会尽量简化你的设计。这类事情很快就会变得一团糟。

是的，重载在编译时得到解决。如果使用C#4，可以强制在执行时对其求值，如下所示：

internal T CallDoSomething<T, U>(string someString, U ints) where T : class
{
    dynamic d = ints;
    return DoSomething<T>(someString, d);
}

internalt-CallDoSomething（string-someString，U-int），其中T:class
{
动态d=整数；
返回DoSomething（someString，d）；
}

---

然而，就我个人而言，如果你可能的话，我会尽量简化你的设计。这类事情很快就会变得一团糟。

我在.NET4中，所以

dynamic

在我的脑海中闪过，但我认为这不会有太大的区别，因为

ints

已经是一个泛型。不过这是有道理的。有没有简化设计的建议？@M.Babcock：通用和动态是非常不同的。泛型是关于在编译时提供更多类型信息；dynamic是关于在执行时使用更多类型信息。至于简化设计-如果不了解更多的上下文，很难说。谢谢你的帮助。我可能会坚持使用代理，只是为了允许在.NET4之外使用。虽然代理解决方案似乎可行，但您知道有什么理由不这样做吗？@M.Babcock：只是简单而已。感觉应该有一个更简单的方法…我在.NET4中，所以我想到了

dynamic

，但我认为这不会有太大的区别，因为

ints

已经是一个通用的方法。不过这是有道理的。有没有简化设计的建议？@M.Babcock：通用和动态是非常不同的。泛型是关于在编译时提供更多类型信息；dynamic是关于在执行时使用更多类型信息。至于简化设计-如果不了解更多的上下文，很难说。谢谢你的帮助。我可能会坚持使用代理，只是为了允许在.NET4之外使用。虽然代理解决方案似乎可行，但您知道有什么理由不这样做吗？@M.Babcock：只是简单而已。感觉应该有一个更简单的方法。。。

internal T CallDoSomething<T, U>(string someString, U ints) where T : class
{
    dynamic d = ints;
    return DoSomething<T>(someString, d);
}