Можно ли обернуть целое число и назвать его как целое число?

Question

Я хочу сделать int в IDictionary<int, Driver> чуть менее запутанным относительно его значения, поэтому я подумал, что, возможно, обернуть его было бы хорошей идеей. Результатом будет что-то вроде IDictionary<finishPosition, Driver>.

Предпочтительно, finPosition должно быть назначено как это finishPosition = 1.

Я не знаю, возможно ли это и как.

Answer 1

Абсолютно, просто используйте это, используя директиву:

using FinishPosition = System.Int32;

в верхней части исходного файла и напишите код так же, как в своем примере.

Если вы используете такую ​​директиву using, FinishPosition - это int, а другие файлы будут видеть его как int - новый тип FinishPosition не определен (спасибо за конфигуратор в комментариях).

Answer 2

Вы можете использовать struct с неявным преобразованием.

public struct FinishPosition {
    public readonly int Position;

    public FinishPosition(int position) {
        this.Position = position;
    }

    public static implicit operator FinishPosition(int position) {
        return new FinishPosition(position);
    }
}


// ...

Dictionary<FinishPosition, Driver> dict = new Dictionary<FinishPosition, Driver>();
Driver bob = new Driver();

// The following two lines are effectively equivalent
dict[new FinishPosition(7)] = bob;
dict[7] = bob;

// So are these two
bob = dict[7];
bob = dict[new FinishPosition(7)]

Answer 3

По моему мнению, хорошо использовать шаблон AbstractDataType везде, где общее значение используется с конкретными намерениями (этот случай был сделан многими другими с примерами, такими как Percentage, ReadonlyString, ConnectionString и т. Д.)

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

Вот пример, который должен вдохновить вас на выбор: вы все равно можете выбрать уровень удобства / многословия, который предпочитаете. Это показывает два подхода:

• _byInt индексирует словарь по PseudoInt
• _byEnum индексирует словарь по типу Enum: int

Примечания

• если вы #define IMPLICIT_CONVERSIONS вы получите неявные преобразования в базовый тип индекса (то есть в int или в перечисление)
• это экстраполирует на все типы значений, включая определенные пользователем (попробуйте это с вашей структурой XYZCoord:))
• посмотрите здесь, если вам действительно нужны преобразования в и из типов Enum

Без лишних слов:

#define IMPLICIT_CONVERSIONS
using System.Collections.Generic;

namespace NS
{
    public enum PositionEnum : int { Begin = 0, Normal = 1, End = 99 }

    public struct Pseudo<T> where T : struct
    {
        public T Value;
        public Pseudo(T value) { Value = value; }
#if IMPLICIT_CONVERSIONS
        public static implicit operator T(Pseudo<T> pi)  { return pi.Value; }
        public static implicit operator Pseudo<T>(T ni)  { return new Pseudo<T>(ni); }
#endif
    }

    static class Program
    {
        private static Pseudo<T> AsPseudo<T>(this T value) where T : struct
        {
            return new Pseudo<T>(value);
        }

        private static readonly IDictionary<Pseudo<int>, string> _byInt = 
            new Dictionary<Pseudo<int>, string>()
                {   { 0,  "aap" },
                    { 1,  "noot" },
                    { 99, "mies" },
                };

        private static readonly IDictionary<Pseudo<PositionEnum>, string> _byEnum = 
            new Dictionary<Pseudo<PositionEnum>, string>()
                {   { PositionEnum.Begin,  "aap" },
                    { PositionEnum.Normal, "noot" },
                    { PositionEnum.End,    "mies" },
                };

        public static void Main(string[] args)
        {
            string s;
            s = _byInt[0];
            s = _byEnum[PositionEnum.Normal];
        }
    }
}

Answer 4

Вы можете использовать перечисление:

enum Position { Finish, Some, Other }

IDictionary<Position, Driver> lookup = ...;

Driver d = lookup[Position.Finish];

Answer 5

Я только что адаптировал базовый класс RichEnum в вопросе, который я связал ранее [1]

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

Перейдите, чтобы понять, что я имею в виду (снова включив полностью запущенный образец):

[1] Можем ли мы определить неявные преобразования перечислений в c #?