Question

我想让IDictionary<int, Driver>中的int对它的含义不那么模糊，所以我想也许包装它会是一个好主意。结果将类似于IDictionary<finishPosition, Driver>。

最好，finishPosition应该像finishPosition = 1一样分配。

我不知道这是否可行以及如何。

Answer 1

当然，只需使用此using指令：

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

您可以使用枚举：

enum Position { Finish, Some, Other }

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

Driver d = lookup[Position.Finish];

Answer 4

在我看来，在一般值与特定意图一起使用的任何地方都可以使用AbstractDataType模式（这种情况已由许多其他人使用Percentage，ReadonlyString，ConnectionString等示例）。

注意，我个人认为对它们进行隐式转换会使整个事情变得空洞（通过隐式转换，没有更多编译器保证在正确的位置使用特定意图的泛型值）

以下是一个应该激发您按照自己的方式启发的示例：您仍然可以选择您喜欢的便利性/详细程度。它显示了两种方法：

_byInt通过PseudoInt索引字典
_byEnum通过Enum：int type

备注

如果您#define IMPLICIT_CONVERSIONS，您将获得对基本索引类型的隐式转换（因此要将int 或转换为枚举）
这推断为所有值类型，包括用户定义的值（尝试使用XYZCoord结构:)）
看看overhere if you really wanted conversions to and from Enum types

没有进一步的麻烦：

#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 5

我刚刚在[1]

之前链接的问题中修改了RichEnum通用基类

我会说我更喜欢这种方法，因为从长远来看它似乎是最灵活的。我能想到的唯一缺点是，RichEnum类型不再是值类型。

转过头来看看我的意思（包括一个完全运行的样本）：

[1] Can we define implicit conversions of enums in c#?

是否可以包装整数并将其称为整数？

5 个答案: