Перегрузка метода по ограничениям типа в C #? [Дубликат]

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

В приведенном ниже примере метод неограниченного использования Foo<T> использует отражение для обработки вызовов на соответствующий ограниченный метод - либо FooWithStruct<T>, либо FooWithClass<T>. По соображениям производительности мы будем создавать и кэшировать строго типизированный делегат, а не использовать обычное отражение каждый раз, когда вызывается метод Foo<T>.

int x = 42;
MyClass.Foo(x);    // displays "Non-Nullable Struct"

int? y = 123;
MyClass.Foo(y);    // displays "Nullable Struct"

string z = "Test";
MyClass.Foo(z);    // displays "Class"

// ...

public static class MyClass
{
    public static void Foo<T>(T? a) where T : struct
    {
        Console.WriteLine("Nullable Struct");
    }

    public static void Foo<T>(T a)
    {
        Type t = typeof(T);

        Delegate action;
        if (!FooDelegateCache.TryGetValue(t, out action))
        {
            MethodInfo mi = t.IsValueType ? FooWithStructInfo : FooWithClassInfo;
            action = Delegate.CreateDelegate(typeof(Action<T>), mi.MakeGenericMethod(t));
            FooDelegateCache.Add(t, action);
        }
        ((Action<T>)action)(a);
    }

    private static void FooWithStruct<T>(T a) where T : struct
    {
        Console.WriteLine("Non-Nullable Struct");
    }

    private static void FooWithClass<T>(T a) where T : class
    {
        Console.WriteLine("Class");
    }

    private static readonly MethodInfo FooWithStructInfo = typeof(MyClass).GetMethod("FooWithStruct", BindingFlags.NonPublic | BindingFlags.Static);
    private static readonly MethodInfo FooWithClassInfo = typeof(MyClass).GetMethod("FooWithClass", BindingFlags.NonPublic | BindingFlags.Static);
    private static readonly Dictionary<Type, Delegate> FooDelegateCache = new Dictionary<Type, Delegate>();
}

(Обратите внимание, что этот пример не является потоковым .Если вам нужна безопасность потоков, вам придется либо использовать какую-то блокировку во всем доступе к кеш-словарю, либо - если вы можете настроить таргетинг на .NET4 - используйте ConcurrentDictionary<K,V> .)

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

static void Foo(object a) { } // reference type
static void Foo<T>(T? a) where T : struct { } // nullable
static void Foo(ValueType a) { } // valuetype

К сожалению, вы не можете различать тип метода для вызова, основанный только на ограничениях.

Поэтому вам нужно определить метод в другом классе или с другим именем.

Снимите ограничение структуры на первый метод. Если вам нужно различать типы значений и классы, вы можете использовать тип аргумента для этого.

      static void Foo( T? a ) where T : struct
      {
         // nullable stuff here
      }

      static void Foo( T a )
      {
         if( a is ValueType )
         {
            // ValueType stuff here
         }
         else
         {
            // class stuff
         }
      }

Усиление моего комментария к LukeH, полезному шаблону, если вам нужно будет использовать Reflection для вызова разных действий на основе параметра типа (в отличие от типа экземпляра объекта), чтобы создать частный общий статический класс, (этот точный код не проверен, но я уже делал это раньше):

static class FooInvoker<T>
{
  public Action<Foo> theAction = configureAction;
  void ActionForOneKindOfThing<TT>(TT param) where TT:thatKindOfThing,T
  {
    ...
  }
  void ActionForAnotherKindOfThing<TT>(TT param) where TT:thatOtherKindOfThing,T
  {
    ...
  }
  void configureAction(T param)
  {
    ... Determine which kind of thing T is, and set `theAction` to one of the
    ... above methods.  Then end with ...
    theAction(param);
  }
}

Обратите внимание, что Reflection генерирует исключение, если попытаться создать делегат для ActionForOneKindOfThing<TT>(TT param), когда TT не соответствует ограничениям этого метода. Поскольку система подтвердила тип TT, когда был создан делегат, можно безопасно вызывать theAction без дальнейшей проверки типов. Также обратите внимание, что если внешний код делает:

  FooInvoker<T>.theAction(param);

, для первого вызова потребуется любое отражение. Последующие вызовы просто вызовут делегата напрямую.