通用类型检查

Question

有没有办法强制/限制传递给基元的类型？ （bool、int、string等）

现在，我知道你可以限制泛型类型通过 where 子句传递给类型或接口实现的参数。 然而，这不符合原语的要求（据我所知），因为它们并不都有共同点（除了有人说之前的对象！：P）。

因此，我目前的想法是咬紧牙关，执行一个大的 switch 语句，并在失败时抛出 ArgumentException 。

---

编辑1：

只是为了澄清：

代码定义应该是这样的：

public class MyClass<GenericType> ....

和实例化：

MyClass<bool> = new MyClass<bool>(); // Legal
MyClass<string> = new MyClass<string>(); // Legal
MyClass<DataSet> = new MyClass<DataSet>(); // Illegal
MyClass<RobsFunkyHat> = new MyClass<RobsFunkyHat>(); // Illegal (but looks awesome!)

---

编辑2

@Jon Limjap - 好点，我已经在考虑了。 我确信有一个通用方法可用于确定该类型是值类型还是引用类型。

这对于立即删除许多我不想处理的对象可能很有用（但随后您需要担心使用的结构，例如 Size ）。 有趣的问题不是吗？ :)

这里是：

where T: struct

取自 MSDN。

---

我很好奇。 这可以在 .NET 3.x 中使用扩展方法来完成吗？ 创建一个接口，并在扩展方法中实现该接口（这可能比一个胖开关更干净）。 另外，如果您稍后需要扩展到任何轻量级自定义类型，它们也可以实现相同的接口，而无需更改基本代码。

你们有什么感想？

不幸的消息是我正在框架 2 中工作！ ：D

---

编辑3

这非常简单，遵循Jon Limjaps Pointer.. 如此简单，我几乎想哭，但这很棒，因为代码工作起来就像一个魅力！

这就是我所做的（你会笑的！）：

将代码添加到泛型类中

bool TypeValid()
{
    // Get the TypeCode from the Primitive Type
    TypeCode code = Type.GetTypeCode(typeof(PrimitiveDataType));

    // All of the TypeCode Enumeration refer Primitive Types
    // with the exception of Object and Empty (Null).
    // Since I am willing to allow Null Types (at this time)
    // all we need to check for is Object!
    switch (code)
    {
        case TypeCode.Object:
            return false;
        default:
            return true;
    }
}

然后使用一个小实用方法来检查类型并引发异常，

private void EnforcePrimitiveType()
{
    if (!TypeValid())
        throw new InvalidOperationException(
            "Unable to Instantiate SimpleMetadata based on the Generic Type of '" + typeof(PrimitiveDataType).Name + 
            "' - this Class is Designed to Work with Primitive Data Types Only.");
}

然后需要做的就是调用 EnforcePrimitiveType() 在类构造函数中。 任务完成！ :-)

唯一的缺点是，它只在运行时（显然）而不是设计时抛出异常。 但这没什么大不了的，可以通过像 FxCop 这样的实用程序来获取（我们不这样做）工作中使用）。

特别感谢 Jon Limjap 对此！

Answer 1

public class Class1<GenericType> where GenericType : struct
{
}

这似乎完成了这项工作..

Answer 2

基元似乎是在 TypeCode 枚举：

也许有一种方法可以查明对象是否包含 TypeCode 枚举，而无需将其强制转换为特定对象或调用 GetType() 或 typeof()？

更新它就在我眼皮子底下。 那里的代码示例表明了这一点：

static void WriteObjectInfo(object testObject)
{
    TypeCode    typeCode = Type.GetTypeCode( testObject.GetType() );

    switch( typeCode )
    {
        case TypeCode.Boolean:
            Console.WriteLine("Boolean: {0}", testObject);
            break;

        case TypeCode.Double:
            Console.WriteLine("Double: {0}", testObject);
            break;

        default:
            Console.WriteLine("{0}: {1}", typeCode.ToString(), testObject);
            break;
        }
    }
}

它仍然是一个丑陋的开关。 但这是一个很好的起点！

Answer 3

几乎就像 @Lars 已经说过的那样：

//Force T to be a value (primitive) type.
public class Class1<T> where T: struct

//Force T to be a reference type.
public class Class1<T> where T: class

//Force T to be a parameterless constructor.
public class Class1<T> where T: new()

所有工作都在 .NET 2、3 和 3.5 中进行。

Answer 4

如果您可以容忍使用工厂方法（而不是您要求的构造函数 MyClass），您总是可以这样做：

class MyClass<T>
{
  private readonly T _value;

  private MyClass(T value) { _value = value; }

  public static MyClass<int> FromInt32(int value) { return new MyClass<int>(value); }
  public static MyClass<string> FromString(string value) { return new MyClass<string>(value); }
  // etc for all the primitive types, or whatever other fixed set of types you are concerned about
}

这里的一个问题是您需要键入 MyClass.FromInt32，这很烦人。 如果您想维护构造函数的私有性，没有一个很好的方法来解决这个问题，但这里有一些解决方法：

• 创建一个抽象类 MyClass。 使 MyClass 继承自 MyClass ，并将其嵌套在 MyClass 中。 将静态方法移至MyClass。 这将解决所有可见性问题，但代价是必须以 MyClass.MyClass 的形式访问 MyClass。
• 使用给定的 MyClass 。 创建一个静态类 MyClass，它使用 MyClass 调用 MyClass 中的静态方法（可能每次都使用适当的类型，只是为了咯咯笑）。
• （更简单，但确实很奇怪）创建一个继承自 MyClass 的抽象类型 MyClass 。 （具体来说，假设为 MyClass。）因为您可以通过派生类的名称调用基类中定义的静态方法，所以您现在可以使用 MyClass.FromString.

这为您提供了静态检查，但代价是更多的写入。

如果您对动态检查感到满意，我会使用上面 TypeCode 解决方案的一些变体。

Answer 5

您可以使用 EnforcePrimitiveType 方法>typeof(PrimitiveDataType).IsPrimitive 属性。 我错过了什么吗？

Answer 6

@Rob，Enum 将通过 TypeValid 函数，因为它的 TypeCode 是 Integer。 我已更新该函数以检查 Enum。

Private Function TypeValid() As Boolean
    Dim g As Type = GetType(T)
    Dim code As TypeCode = Type.GetTypeCode(g)

    ' All of the TypeCode Enumeration refer Primitive Types
    ' with the exception of Object and Empty (Nothing).
    ' Note: must also catch Enum as its type is Integer.
    Select Case code
        Case TypeCode.Object
            Return False
        Case Else
            ' Enum's TypeCode is Integer, so check BaseType
            If g.BaseType Is GetType(System.Enum) Then
                Return False
            Else
                Return True
            End If
    End Select
End Function

Answer 7

面临类似的挑战，我想知道你们对 IConvertible 界面< /a>. 它允许请求者要求的内容，并且您可以使用自己的实现进行扩展。

示例：

    public class MyClass<TKey>
    where TKey : IConvertible
{
    // class intentionally abbreviated
}

我正在考虑将此作为解决方案，尽管许多建议也是我选择的一部分。

然而，我担心的是，它是否会误导使用您的类的潜在开发人员？

干杯 - 谢谢。

Answer 8

使用自定义 FxCop 规则来标记 MyClass<>。

Answer 9

在dotnet 6中，我在使用struct时遇到了这个错误：

类型“string”必须是不可为 null 的值类型才能将其用作参数“T”

所以我使用 IConvertible

var intClass = new PrimitivesOnly<int>();
var doubleClass = new PrimitivesOnly<double>();
var boolClass = new PrimitivesOnly<bool>();
var stringClass = new PrimitivesOnly<string>();
var myAwesomeClass = new PrimitivesOnly<MyAwesomeClass>(); // illegal

// The line below encounter issue when using "string" type
// class PrimitivesOnly<T> where T : struct
class PrimitivesOnly<T> where T : IConvertible
{
    
}

class MyAwesomeClass
{
}