Перегрузка метода с помощью типов С#

Ответ 1

То, что вы пытаетесь сделать, возможно следующим образом:

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

В то время как это возможно, вы как бы побеждаете цель дженериков. Точка дженериков - это когда тип не имеет значения, поэтому я не думаю, что в этом случае подходящими являются дженерики.

Ответ 2

"Специализация" на С# невозможна, как в С++. В генерических файлах .NET общий класс или метод <T> должно быть одинаковым для всех возможных значений T. Это позволяет среде выполнения оптимизировать два разных типа ссылок, например TestClass <string> и TestClass < List <int> , используют один и тот же код машинного языка. (разные типы значений получают отдельный машинный код, но вы все еще не можете специализироваться.)

Я нахожу, что иногда помогает создать общий интерфейс или базовый класс следующим образом:

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; }
}

Ответ 3

В С# специализация невозможна. Самая близкая вещь в С# следующая

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

Компилятор С# предпочтет не общий метод для общего метода. Это означает, что вызов с int paramater будет привязан к перегрузке 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>()

Ответ 4

Нет, это невозможно. То, что вы пытаетесь сделать, похоже на специализированную специализацию на С++, которая (к сожалению) невозможна в С#.

Вам нужно, если /else или включить

typeof(T)

для вызова специализированных реализаций.

Тем не менее, вы можете ограничить тип T либо классом (ссылочным значением), либо структурой (значением) или подклассом определенного базового слова следующим образом:

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

Ответ 5

Будут ли использоваться методы расширения класса?

Вы можете существенно добавлять методы к классам, которые хотите, а затем вы можете называть их одинаково.

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

называется:

myString.GetName();

Ответ 6

С# не поддерживает такую ​​диспетчеризацию.

и это неправильный способ для перегрузки методов также (Error'TestClass уже определяет член, называемый "GetName" с теми же типами параметров), если все внутри < > не является частью сигнатуры метода.

Ответ 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
}

Ответ 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;
}

В основном вы просто рассказываете фреймворку Reflection, чтобы сделать этот оператор switch для вас.