泛型约束,其中t:struct和where t:class

约束不是签名的一部分,但参数是。在过载解决过程中强制执行参数中的约束。

所以让我们把约束放到一个参数中。它很难看,但很管用。

class RequireStruct<T> where T : struct { }
class RequireClass<T> where T : class { }

static void Foo<T>(T a, RequireStruct<T> ignore = null) where T : struct { } // 1
static void Foo<T>(T? a) where T : struct { } // 2
static void Foo<T>(T a, RequireClass<T> ignore = null) where T : class { } // 3

(迟六年总比不迟一年好吗?)

不幸的是,您不能仅根据约束来区分要调用的方法的类型。

因此,您需要在不同的类中或用不同的名称来定义一个方法。

关于你的评论 Marnix's answer 你可以通过一点反思来实现你想要的。

在下面的示例中,不受约束的 Foo<T> 方法使用反射将调用分为适当的约束方法-或者 FooWithStruct<T> 或 FooWithClass<T> . 出于性能原因,我们将创建和缓存强类型委托,而不是每次 FO & 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>();
}

(注意 此示例不是threadsafe . 如果您需要线程安全,那么您要么需要在对缓存字典的所有访问周围使用某种类型的锁定,要么——如果您能够以.net4为目标——使用 ConcurrentDictionary<K,V> 取而代之的是)

删除第一个方法的结构约束。如果需要区分值类型和类,可以使用参数的类型来区分。

      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,如果需要使用反射来调用基于类型参数的不同操作(与对象实例的类型不同),那么一个有用的模式是创建一个私有的通用静态类,类似于以下内容(这个确切的代码是未经测试的,但我以前做过这种事情):

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

请注意,如果试图为创建委托,则反射将引发异常 ActionForOneKindOfThing<TT>(TT param) 什么时候 TT 不符合该方法的约束。因为系统验证了 TT 创建委托时,可以安全地调用 theAction 无需进一步的类型检查。还要注意,如果外部代码有:

  FooInvoker<T>.theAction(param);

只有第一个调用需要任何反射。后续调用将直接调用委托。

如果不需要通用参数,只想在编译时区分这三种情况,可以使用以下代码。

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

值得庆幸的是,从C版本7.3开始,这种混乱不需要那么多。

见 Whats new in C# 7.3 -它不是很明确,但在重载解析期间,它现在似乎在某种程度上使用了“where”参数。

过载解决方案现在具有较少的不明确情况

也看到 Selecting C# Version 在您的Visual Studio项目中

它仍将看到与以下内容的冲突

Foo(x);
...
static void Foo<T>(T a) where T : class { } // 3
static void Foo<T>(T a) where T : struct { } // 3

但会正确解决

Foo(x);
...
static void Foo<T>(T a, bool b = false) where T : class { } // 3
static void Foo<T>(T a) where T : struct { } // 3