通用约束，其中 T : struct 和 where T : class

Question

我想区分以下情况：

1. 普通值类型（例如int）
2. 可以为空的值类型（例如int?）
3. 引用类型（例如string） - 可选，我不关心它是否映射到上面的 (1) 或 (2)

我想出了以下代码，适用于情况（1）和（2）：

static void Foo<T>(T a) where T : struct { } // 1

static void Foo<T>(T? a) where T : struct { } // 2

但是，如果我尝试像这样检测案例 (3)，它不会编译：

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

错误消息是类型“X”已经定义了一个名为“Foo”的成员，具有相同的参数类型。好吧，不知何故，我无法区分 where T : struct 和 where T : class。

如果我删除第三个函数（3），下面的代码也不会编译：

int x = 1;
int? y = 2;
string z = "a";

Foo (x); // OK, calls (1)
Foo (y); // OK, calls (2)
Foo (z); // error: the type 'string' must be a non-nullable value type ...

如何让Foo(z) 进行编译，将其映射到上述函数之一（或第三个具有另一个约束的函数，我没有想到）？

Answer 1

约束不是签名的一部分，但参数是。并且在重载决议期间强制执行参数中的约束。

所以让我们把约束放在一个参数中。这很丑陋，但它有效。

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

（迟到六年总比没有好？）

Answer 2

很遗憾，您无法仅根据约束来区分要调用的方法类型。

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

Answer 3

除了你对Marnix's answer的评论，你可以通过一点反思来实现你想要的。

在下面的示例中，不受约束的 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>。）

Answer 4

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

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

Answer 5

放大我对 LukeH 的评论，如果需要使用反射来调用基于类型参数的不同操作（与对象实例的类型不同），一种有用的模式是创建一个私有的通用静态类，类似于以下（这个确切的代码未经测试，但我以前做过这种事情）：

静态类 FooInvoker { public Action theAction = configureAction; void ActionForOneKindOfThing(TT param) where TT:thatKindOfThing,T { ... } void ActionForAnotherKindOfThing(TT param) where TT:thatOtherKindOfThing,T { ... } 无效配置操作（T参数） { ... 确定 T 是哪种事物，并将 `theAction` 设置为 ...上述方法。然后以...结束 动作（参数）； } }

请注意，如果在 TT 不符合该方法的约束时尝试为 ActionForOneKindOfThing<TT>(TT param) 创建委托，反射将引发异常。因为系统在创建委托时验证了TT 的类型，所以可以安全地调用theAction 而无需进一步的类型检查。另请注意，如果外部代码这样做：

FooInvoker.theAction(param);

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

Answer 6

谢天谢地，从 C# 版本 7.3 开始，这种乱七八糟的事情就更少了

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

重载解析现在有更少的模棱两可的情况

另请参阅您的 Visual Studio 项目中的 Selecting C# Version

它仍然会与以下内容发生冲突

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

Answer 7

如果您不需要泛型参数并且只想在编译时区分这三种情况，您可以使用以下代码。

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