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

Есть ли способ принудительного применения / ограничения типов, передаваемых примитивам? (bool, int, string и т. д.)

Теперь я знаю, что вы можете ограничить универсальный параметр типа реализацией типа или интерфейса с помощью предложения where. Тем не менее, это не соответствует требованиям для примитивов (AFAIK), потому что они не все имеют общую почву (кроме объекта, прежде чем кто-то скажет!:P).

Итак, мои нынешние мысли - просто стиснуть зубы, сделать большое заявление о переключении и выдать 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 - Хороший вопрос, и кое-что, что я уже рассматривал.. Я уверен, что есть универсальный метод, который можно использовать, чтобы определить, является ли тип значением или ссылочным типом.

Это может быть полезно для мгновенного удаления множества объектов, с которыми я не хочу иметь дело (но тогда вам нужно беспокоиться о таких структурах, как Размер). Интересной проблемы нет?:)

Вот:

where T : struct

Взято из MSDN.


Мне интересно... Может ли это быть сделано в.NET 3.x с использованием методов расширения? Создайте интерфейс и реализуйте интерфейс в методах расширения (которые, вероятно, будут чище, чем немного жирный переключатель). Кроме того, если затем вам потребуется расширить на любые легковесные пользовательские типы, они также могут реализовать тот же интерфейс без изменений в базовом коде.

Что, вы парни, думаете?

Печальная новость - я работаю в Framework 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 (которые мы не используем на работе).

Отдельное спасибо Джону Лимджапу за это!

8 ответов

Решение

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

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

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

Этот, казалось, сделал работу..

В значительной степени то, что @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 выше.

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

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

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

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

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

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

Другие вопросы по тегам