C# 类型的方法重载

Question

我想知道以下是否可能。创建一个接受匿名类型（string、int、decimal、customObject 等）的类，然后具有根据类型执行不同操作的重载方法。示例

    class TestClass<T>
{
  public void GetName<string>()
  {
      //do work knowing that the type is a string    
  }

  public string GetName<int>()
  {
      //do work knowing that the type is an int

  } 

  public string GetName<int>(int addNumber)
  {
      //do work knowing that the type is an int (overloaded)    
  } 

  public string GetName<DateTime>()
  {
      //do work knowing that the type is a DateTime

  } 

  public string GetName<customObject>()
  {
      //do work knowing that the type is a customObject type    
  }

}

现在我可以调用 GetName 方法，并且因为我在初始化对象时已经传入了类型，所以会找到并执行正确的方法。

TestClass foo = new TestClass<int>();

//executes the second method because that's the only one with a "int" type
foo.GetName();

这是可能的还是我只是在做梦？

Answer 1

您尝试做的事情是可能的，如下所示：

class TestClass<T>
{
   public string GetName<T>()
   {
      Type typeOfT = typeof(T);
      if(typeOfT == typeof(string))
      {
          //do string stuff
      }
   }
}

虽然这是可能的，但您有点违背了泛型的目的。泛型的要点是当类型不重要时，所以我认为泛型在这种情况下不合适。

Answer 2

“专业化”在 C# 中不可能像在 C++ 中那样。在 .NET 泛型中， 的泛型类或方法可以被定义为泛型。对于 T 的所有可能值必须相同。这允许运行时对两种不同的引用类型（例如 TestClass）进行优化。和 TestClass> 共享相同的机器语言代码。 （不同的值类型获得单独的机器代码，但您仍然无法专门化。）

我发现有时有助于创建像这样的通用接口或基类：

abstract class Base<T> {
  public abstract T GetName();
  // any common code goes here that does not require specialization
}

并在派生类中进行专门化：

class IntVersion : Base<int> {
  public override int GetName() { return 1; }
  public int GetName(int addNumber) { ... }
}
class StringVersion : Base<string> {
  public override string GetName() { return "foo"; }
}
class DateTimeVersion : Base<DateTime> {
  public override DateTime GetName() { return DateTime.Now; }
}

Answer 3

C# 中不可能进行专业化。 C# 中最接近的内容如下：

public void Example() {
  public static void Method<T>(T value) { ... }
  public static void Method(int value){ ... }
  public static void Method(string) { ... }
}

C# 编译器会优先选择非泛型方法而不是泛型方法。这意味着使用 int 参数调用将绑定到 int 重载而不是通用重载。

Example.Method(42);  // Method(int)
Example.Method(new Class1())  // Method<T>(T)

但这会让您感到困扰，因为当一般调用该方法时，这并不适用。在这种情况下，无论类型如何，它都会绑定到泛型重载。

public void Gotcha<T>(T value) {
  Example.Method(value);
}

Gotcha(42);  // Still calls Example.Method<T>()

Answer 4

不，这是不可能的。您尝试做的事情类似于 C++ 中的模板专业化，（遗憾的是）这在 C# 中是不可能的。

您需要 if/else 或 switch on

typeof(T)

来调用专门的实现。

但是，您可以将 T 的类型限制为类（引用值）或结构（值）或某个基类的子类，如下所示：

 public Foo<T> DoBar<T>() where T : FooBase;

Answer 5

c# 不支持此类调度。

这也不是进行方法重载的正确方法（Error'TestClass' 已经定义了一个名为 'GetName' 且具有相同参数类型的成员），只要 <> 内的所有内容都正确。不是方法签名的一部分。

Answer 6

使用类扩展方法对您有用吗？

您本质上可以向所需的类添加方法，然后可以以相同的方式调用它。

namespace ExtensionMethods
{
    public static class MyExtensions
    {
        public static int GetName(this String str)
        {
            ...
        }
    }   
}

调用使用：

myString.GetName();

Answer 7

如果您需要在类中执行特定于类型的工作，那么您的类就不是通用的。您可能应该为要处理的每种类型创建一个单独的类。如果某些功能确实有适当的理由成为通用的，则可以将其放入公共基类中。

一个例子：

abstract class TestClass<T>
{
    public List<T> Items { get; set; }

    // other generic (i.e. non type-specific) code
}

class IntTestClass : TestClass<int>
{
    public string GetName()
    {
        // do work knowing that the type is an int
    }

    // other code specific to the int case
}

class StringTestClass : TestClass<string>
{
    public string GetName()
    {
        // do work knowing that the type is a string
    }

    // other code specific to the string case
}

Answer 8

正如 BFree 提到的，您可以使用 if 树或更可能是 switch 语句来做到这一点，但在某些时候您会希望只编写方法并让 .Net 来解决它，特别是如果您随着时间的推移增加重载库的话。

解决方案是反射，尽管它在 .Net 中的性能相当便宜：

using System.Reflection;
...

public string DoSomething(object val)
{
    // Force the concrete type
    var typeArgs = new Type[] { val.GetType() };

    // Avoid hard-coding the overloaded method name
    string methodName = new Func<string, string>(GetName).Method.Name;

    // Use BindingFlags.NonPublic instead of Public, if protected or private
    var bindingFlags = BindingFlags.Public | BindingFlags.Instance;

    var method = this.GetType().GetMethod(
        methodName, bindingFlags, null, typeArgs, null);

    string s = (string)method.Invoke(this, new object[] { val });

    return s;
}

您基本上只是告诉反射框架为您执行该 switch 语句。