泛型类型参数的约束

Question

考虑下面的通用类：

public class Custom<T> where T : string 
{ 
} 

这将产生以下错误：

'string' is not a valid constraint. A type used as a constraint must be an interface, a non-sealed class or a type parameter.

有另一种方式来约束我的泛型类可以使用哪些类型？

此外，我可以限制到多种类型？

E.G.

T can only be string, int or byte

Answer 1

public class Custom<T> where T : string 

是不允许的，因为只有T满足那就是：string（string是sealed） - 使得它相当无意义作为一种通用的。

Also, can I constrain to multiple types?

没有 - 除非你做的，而不是约束通过反射运行时（静态构造函数是做的一个方法 - 抛出一个异常，如果使用不当）

T can only be string, int or byte

你威力使用类似IEquatable<T>的东西，但这并不会像您想的那样限制它，所以最终：不。

你的东西可能做的是通过一个重载的工厂访问它：

public abstract class Custom 
{ 
    public static Custom Create(int value) 
    { return new CustomImpl<int>(value); } 
    public static Custom Create(byte value) 
    { return new CustomImpl<byte>(value); } 
    public static Custom Create(string value) 
    { return new CustomImpl<string>(value); } 
    private class CustomImpl<T> : Custom 
    { 
     public CustomImpl(T val) { /*...*/ } 
    } 
} 

Answer 2

从我的经验，我会说，我理解你为什么想有，string和int ......因为一个通用基类ID类型字符串或int

但是这是肯定的，这是不可能的。由于此MSDN的描述说： http://msdn.microsoft.com/en-us/library/d5x73970%28v=vs.80%29.aspx

我们可以有一个constraing class（如串参考对象）或struct（值类型如int） 那么混合字符串和INT将是不可能的

注意：错误因为字符串是有意义的，因为字符串是密封的，所以它不一定是通用的 - 字符串ID是我们需要的

Answer 3

在回顾这里的答案后，我有一点点玩弄自己，我已经出现了与下面的实现，它检查运行时约束而不是编译时间。

// This example takes 3 parameters... 
public class GenericConstraint<T1, T2, T3> 
{ 
    public GenericConstraint(Type type) 
    { 
     if (!(type is T1) || !(type is T2) || !(type is T3)) 
     { 
      throw new Exception("This is not a supported type"); 
     } 
    } 
} 

现在我继承了我的自定义类...

public class Custom<T> : GenericConstraint<string, int, byte> 
{ 
    public Custom() : base(typeof(T)) 
    { 
    } 
} 

现在，这将引发一个错误：

Custom<long> item = new Custom<long>(); 

这不！

Custom<byte> item2 = new Custom<byte>(); 

正如Marc Gravell所述，这不是继承或泛型的好用法。通过继承GenericConstraint从逻辑上思考，这只是限制继承，并且也没有正确使用类型层次结构。就泛型的使用而言，这实际上毫无意义！

因此，我有另一个解决方案作为一个辅助方法来限制运行时的类型。这从继承中释放了对象，因此对类型层次结构没有影响。

public static void ConstrainParameterType(Type parameterType, GenericConstraint constraintType, params Type[] allowedTypes) 
     { 
      if (constraintType == GenericConstraint.ExactType) 
      { 
       if (!allowedTypes.Contains<Type>(parameterType)) 
       { 
        throw new Exception("A runtime constraint disallows use of type " + parameterType.Name + " with this parameter."); 
       } 
      } 
      else 
      { 
       foreach (Type constraint in allowedTypes) 
       { 
        if (!constraint.IsAssignableFrom(parameterType)) 
        { 
         throw new Exception("A runtime constraint disallows use of type " + parameterType.Name + " with this parameter."); 
        } 
       } 
      } 
     } 

public enum GenericConstraint 
    { 
     /// <summary> 
     /// The type must be exact. 
     /// </summary> 
     ExactType, 

     /// <summary> 
     /// The type must be assignable. 
     /// </summary> 
     AssignableType 
    } 

现在这允许在普通对象的多个类型的限制，即使类型密封等

"public class Custom where T : string ... is not allowed, because the only T that meets that is: string (string is sealed) - making it rather pointless as a generic."

是的，这是没有意义的，但在某些情况下，您可能希望将对象约束允许，例如;字符串，StringBuilder和SecureString。虽然这不提供编译时间约束，但它确实提供了运行时约束，并且在约束中可以使用哪些类型的一些灵活性。