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

Question

我想让IDictionary<int, Driver>中的整数在它的意义上稍微模糊一点，所以我想也许包装它会是一个好主意。结果将如IDictionary<finishPosition, Driver>。

优选地，finishPosition应该可以像这样分配finishPosition = 1。

我不知道这是可能的以及如何。

Answer 1

您可以使用带有隐式转换的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 2

你可以使用一个枚举：

enum Position { Finish, Some, Other } 

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

Driver d = lookup[Position.Finish]; 

Answer 3

绝对的，只是用这个using指令：

using FinishPosition = System.Int32;

在你的源文件的顶部，并编写代码，就像你有在你的例子中。

如果你这样使用using指令，FinishPosition是一个int，其他文件将会把它看作一个int - 没有定义新的FinishPosition类型（感谢评论中的配置器）。

Answer 4

在我看来，在一般的值与特定的意图使用（这种情况下，已经取得了许多人喜欢用百分比，ReadonlyString，ConnectionString的实例等）

这是很好的任何地方使用AbstractDataType模式

请注意，我个人认为，通过隐式转换可以让整个事情变得空洞（通过隐式转换，没有更多的编译器保证通用值在特定位置与正确的位置一起使用） 。

下面是一个应该鼓励您按照自己的方式使用的示例：您仍然可以选择您喜欢的便利/详细程度。这表明两种方法：

• _byInt指数一本词典PseudoInt
• _byEnum指数一本词典的枚举：整型

注

• 如果你＃定义IMPLICIT_CONVERSIONS你会隐式转换为基本索引类型（因此可以将int 或转换为enum）
• 这种外推到所有的值类型，包括用户自定义的人（你的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

我刚刚适应了在我之前链接的问题中的RichEnum泛型基类[1]

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

头以上明白我的意思（也包括完全运行示例）：

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