Проверка общего типа

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

Похоже, это сработало ...

Используйте специальное правило FxCop, которое отмечает нежелательное использование MyClass<>.

Примитивы, по-видимому, указаны в перечислении TypeCode:

Возможно, есть способ узнать, содержит ли объект TypeCode enum, без необходимости приводить его к конкретному объекту или вызывать 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;
        }
    }
}

Это по-прежнему уродливый переключатель. Но это хорошее место для начала!

Примерно то, что уже сказал @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.

Если вы можете терпеть использование фабричных методов (вместо конструкторов 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<AnyTypeItDoesntMatter>.FromInt32, что раздражает. Это не очень хороший способ обойти это, если вы хотите сохранить конфиденциальность конструктора, но вот несколько обходных путей:

• Создайте абстрактный класс MyClass. Сделайте MyClass<T> наследованием от MyClassи вложить его в MyClass. Переместите статические методы в MyClass. Это сделает всю видимость за счет доступа к MyClass<T> как MyClass.MyClass<T>.
• Используйте MyClass<T>, как указано. Создайте статический класс MyClass, который вызывает статические методы в MyClass<T> с использованием MyClass<AnyTypeItDoesntMatter> (возможно, каждый раз используя соответствующий тип, просто для хихиканья).
• (Проще, но конечно странно) Сделайте абстрактный тип MyClassкоторый наследуется от MyClass<AnyTypeItDoesntMatter>. (Для конкретности скажем MyClass<int>.) Поскольку вы можете вызывать статические методы, определенные в базовом классе, через имя производного класса, теперь вы можете использовать MyClass.FromString.

Это дает вам статическую проверку за счет большего количества записей.

Если вам нравится динамическая проверка, я бы использовал вариант решения TypeCode выше.

Вы можете упростить метод EnforcePrimitiveType, используя свойство typeof(PrimitiveDataType).IsPrimitive. Я что-то пропустил?

@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

Столкнувшись с подобной проблемой, мне было интересно, как вы, ребята, относитесь к IConvertible интерфейс. Он позволяет то, что требует запрашивающий, и вы можете расширять свои собственные реализации.

Пример:

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

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

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

Ура - и спасибо.