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

Ответ 1

Примитивы, как представляется, указаны в 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;
        }
    }
}

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

Ответ 2

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

Казалось, что это сработало.

Ответ 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.

Ответ 4

Если вы можете терпеть использование методов factory (вместо запрошенных вами конструкторов 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 выше.

Ответ 5

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

Ответ 6

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

Ответ 7

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

Ответ 8

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

Пример:

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

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

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

Приветствия - и спасибо.