Как псевдоним встроенного типа в C #?

Question

Так что в C ++ я привык делать:

typedef int PeerId;

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

Я думаю, что могу использовать оператор using, но этоЯ считаю, что в текущем файле есть область видимости, поэтому она не будет работать (псевдоним должен быть доступен для нескольких файлов без переопределения).Я также не могу извлечь класс из встроенных типов (но обычно это то, что я бы сделал для псевдонимов ref-типов, таких как List или Dictionary).Я не уверен, что я могу сделать.Есть идеи?

Answer 1

Вам необходимо использовать полное имя типа, например:

using DWORD = System.Int32;

Answer 2

Резюме

Вот краткий ответ:

• Typedefs на самом деле является переменной, используемой генераторами кода во время компиляции.
• C # разрабатывается, чтобы избежать добавления языковых конструкций генерации кода.

Следовательно, концепция typedefs не вписывается в язык C #.

Длинный ответ

В C ++ это имеет больше смысла: C ++ начинал как прекомпилятор, который выплевывал код C, который затем компилировался. Это начало «генератора кода» по-прежнему оказывает влияние на современные функции C ++ (т. Е. Шаблоны по существу являются языком, полным по Тьюрингу, для генерации классов и функций во время компиляции). В этом контексте typedef имеет смысл, потому что это способ получить «результат» фабрики типов времени компиляции или «алгоритм», который «возвращает» тип.

В этом странном мета-языке (который освоили немногие за пределами Boost), typedef на самом деле является переменной.

То, что вы описываете, менее сложно, но вы все еще пытаетесь использовать typedef как переменную. В этом случае он используется в качестве входной переменной. Поэтому, когда другой код использует typedef, он на самом деле не использует этот тип напрямую. Скорее, он действует как генератор кода во время компиляции, создавая классы и методы, основанные на вводимых переменных typedef. Даже если вы игнорируете шаблоны C ++ и просто смотрите на определения типов C, эффект тот же.

C ++ и генеративное программирование

C ++ был разработан, чтобы быть многопараметрическим языком (ОО и процедурный, но не функциональный до выхода Boost). Интересно, что шаблоны развили неожиданный парадайн: генеративное программирование. (Генеративное программирование существовало до C ++, но C ++ сделало его популярным). Генеративные программы - это на самом деле метапрограммы, которые при компиляции генерируют необходимые классы и методы, которые, в свою очередь, компилируются в исполняемые файлы.

C # и генеративное программирование

Наши инструменты медленно развиваются в том же направлении. Конечно, рефлекторный излучатель можно использовать для «ручного» генеративного программирования, но это довольно болезненно. То, как провайдеры LINQ используют деревья выражений, носит очень генеративный характер. Шаблоны T4 очень близки, но все еще не дотягивают. «Компилятор как сервис», который, как мы надеемся, будет частью C # vNext, представляется наиболее перспективным, если его можно объединить с некоторой переменной типа (такой как typedef).

Эта единственная часть головоломки все еще отсутствует : генеративным программам нужен какой-то механизм автоматического запуска (в C ++ это обрабатывается неявным созданием шаблона ).

Однако, явно не цель C # иметь какой-либо «генератор кода» на языке C #, такой как шаблоны C ++ (вероятно, ради понятности; очень немногие программисты C ++ понимают шаблоны C ++ ). Это, вероятно, будет нишей, удовлетворенной T4, а не C #.

Заключение (повторяя резюме)

Все вышесказанное означает следующее:

• Typedefs - это переменная, используемая генераторами кода.
• C # разрабатывается, чтобы избежать добавления языковых конструкций генерации кода.

Следовательно, концепция typedefs не вписывается в язык C #.

Answer 3

Вы можете (ab) использовать неявные преобразования:

struct PeerId
{
    private int peer;

    public static implicit operator PeerId(int i)
    {
        return new PeerId {peer=i};
    }

    public static implicit operator int(PeerId p)
    {
        return p.peer;
    }
}

Это занимает то же пространство, что и int, и вы можете сделать:

PeerId p = 3;
int i = p;

Но я согласен, что вам, вероятно, это не нужно.

Answer 4

Я также иногда чувствую, что мне нужны (целочисленные) typedef для целей, аналогичных OP.

Если вы не возражаете против явных приведений (я действительно хочу, чтобы они были), вы можете сделать это:

enum PeerId : int {};

Также будет работать для byte, sbyte, short, ushort, uint, long, или ulong (очевидно).

Не совсем предполагаемое использование enum, но оно работает.

Answer 5

Переопределение фундаментальных типов только для того, чтобы изменить имя, - это C ++ Think и не подходит для более чистого Object Orientated C #.Всякий раз, когда у вас возникает желание перенести концепцию с одного языка на другой, вы должны остановиться и подумать, имеет ли это смысл или нет, и попытаться остаться родным для платформы.

Требование способности изменять базовыйТип легко может быть удовлетворен путем определения вашего собственного типа значения.В сочетании с неявными операторами преобразования и арифметическими операторами вы можете определять очень мощные типы.Если вы беспокоитесь о производительности при добавлении слоев поверх простых типов, не делайте этого.С вероятностью 99% это не произойдет, а с вероятностью 1%, если это произойдет, это не будет «низко висящим плодом» оптимизации производительности.