blocks|key|1532580|text|如果枚举项的值是连续的，则数组方法可以很好地工作。但是，在任何情况下，您都可以使用Dictionary<DayOfTheWeek,+string>+(顺便说一句，它的性能较差)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1532581|entityMap^0|15|W|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

If the values of your enum items are contigious, the array method works pretty well. However, in any case, you could use <code>Dictionary&lt;DayOfTheWeek, string&gt;</code> (which is less performant, by the way).

blocks|key|1317458|text|这就是了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317459|string[]+message_array+=+Enum.GetNames(typeof(DaysOfTheWeek));|code-block|syntax|javascript|1317460|如果您确实需要长度，那么只需对结果进行.Length+:)，您可以通过以下命令获得值：|1317461|string[]+message_array+=+Enum.GetValues(typeof(DaysOfTheWeek));|1317462|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here you go:

<pre><code>string[] message_array = Enum.GetNames(typeof(DaysOfTheWeek));
</code></pre>

If you really need the length, then just take the .Length on the result :)
You can get values with:

<pre><code>string[] message_array = Enum.GetValues(typeof(DaysOfTheWeek));
</code></pre>

blocks|key|1317522|text|您总是可以执行一些额外的映射，以一致且定义的方式获取枚举值的数组索引：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317523|int+ArrayIndexFromDaysOfTheWeekEnum(DaysOfWeek+day)
{
+++switch+(day)
+++{
+++++case+DaysOfWeek.Sunday:+return+0;
+++++case+DaysOfWeek.Monday:+return+1;
+++++...
+++++default:+throw+...;
+++}
}|code-block|syntax|javascript|1317524|尽可能具体一点。有一天，有人会修改您的枚举，代码将会失败，因为枚举的值被(错误地)用作数组索引。|1317525|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can always do some extra mapping to get an array index of an enum value in a consistent and defined way:

<pre><code>int ArrayIndexFromDaysOfTheWeekEnum(DaysOfWeek day)
{
 switch (day)
 {
 case DaysOfWeek.Sunday: return 0;
 case DaysOfWeek.Monday: return 1;
 ...
 default: throw ...;
 }
}
</code></pre>

Be as specific as you can. One day someone will modify your enum and the code will fail because the enum's value was (mis)used as an array index.

blocks|key|1317581|text|枚举的紧凑形式，用作索引，并将任何类型分配给字典和强类型。在这种情况下，将返回浮点值，但值可以是具有属性和方法等的复杂类实例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317582|enum+opacityLevel+{+Min,+Default,+Max+}
private+static+readonly+Dictionary<opacityLevel,+float>+_oLevels+=+new+Dictionary<opacityLevel,+float>
{
++++{+opacityLevel.Max,+40.0+},
++++{+opacityLevel.Default,+50.0+},
++++{+opacityLevel.Min,+100.0+}
};

//Access+float+value+like+this
var+x+=+_oLevels[opacitylevel.Default];|code-block|syntax|javascript|1317583|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Compact form of enum used as index and assigning whatever type to a Dictionary
and strongly typed. In this case float values are returned but values could be complex Class instances having properties and methods and more:

<pre><code>enum opacityLevel { Min, Default, Max }
private static readonly Dictionary&lt;opacityLevel, float&gt; _oLevels = new Dictionary&lt;opacityLevel, float&gt;
{
 { opacityLevel.Max, 40.0 },
 { opacityLevel.Default, 50.0 },
 { opacityLevel.Min, 100.0 }
};

//Access float value like this
var x = _oLevels[opacitylevel.Default];
</code></pre>

blocks|key|1317663|text|如果您所需要的只是一个映射，但又不想引起与字典查找相关的性能开销，那么这可能是可行的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317664|++++public+class+EnumIndexedArray<TKey,+T>+:+IEnumerable<KeyValuePair<TKey,+T>>+where+TKey+:+struct
++++{
++++++++public+EnumIndexedArray()
++++++++{
++++++++++++if+(!typeof+(TKey).IsEnum)+throw+new+InvalidOperationException("Generic+type+argument+is+not+an+Enum");
++++++++++++var+size+=+Convert.ToInt32(Keys.Max())+%2B+1;
++++++++++++Values+=+new+T[size];
++++++++}

++++++++protected+T[]+Values;

++++++++public+static+IEnumerable<TKey>+Keys
++++++++{
++++++++++++get+{+return+Enum.GetValues(typeof+(TKey)).OfType<TKey>();+}
++++++++}

++++++++public+T+this[TKey+index]
++++++++{
++++++++++++get+{+return+Values[Convert.ToInt32(index)];+}
++++++++++++set+{+Values[Convert.ToInt32(index)]+=+value;+}
++++++++}

++++++++private+IEnumerable<KeyValuePair<TKey,+T>>+CreateEnumerable()
++++++++{
++++++++++++return+Keys.Select(key+=>+new+KeyValuePair<TKey,+T>(key,+Values[Convert.ToInt32(key)]));
++++++++}

++++++++public+IEnumerator<KeyValuePair<TKey,+T>>+GetEnumerator()
++++++++{
++++++++++++return+CreateEnumerable().GetEnumerator();
++++++++}

++++++++IEnumerator+IEnumerable.GetEnumerator()
++++++++{
++++++++++++return+GetEnumerator();
++++++++}
++++}|code-block|syntax|javascript|1317665|所以在你的例子中，你可以推导出：|1317666|class+DaysOfWeekToStringsMap:EnumIndexedArray<DayOfWeek,string>{};|1317667|用法：|1317668|var+map+=+new+DaysOfWeekToStringsMap();

//using+the+Keys+static+property
foreach(var+day+in+DaysOfWeekToStringsMap.Keys){
++++map[day]+=+day.ToString();
}
foreach(var+day+in+DaysOfWeekToStringsMap.Keys){
++++Console.WriteLine("map[{0}]={1}",day,+map[day]);
}

//+using+iterator
foreach(var+value+in+map){
++++Console.WriteLine("map[{0}]={1}",value.Key,+value.Value);
}|1317669|显然，这个实现是由数组支持的，所以不连续的枚举如下所示：|1317670|enum
{
++Ok+=+1,
++NotOk+=+1000000
}|1317671|会导致过多的内存使用。|1317672|如果您需要最大可能的性能，您可能希望使它不那么通用，并松开我必须用来使其编译和工作的所有通用枚举处理代码。我没有对此进行基准测试，所以也许这没什么大不了的。|1317673|缓存Keys静态属性也可能有所帮助。|1317674|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

If all you need is essentially a map, but don't want to incur performance overhead associated with dictionary lookups, this might work:

<pre><code> public class EnumIndexedArray&lt;TKey, T&gt; : IEnumerable&lt;KeyValuePair&lt;TKey, T&gt;&gt; where TKey : struct
 {
 public EnumIndexedArray()
 {
 if (!typeof (TKey).IsEnum) throw new InvalidOperationException("Generic type argument is not an Enum");
 var size = Convert.ToInt32(Keys.Max()) + 1;
 Values = new T[size];
 }

 protected T[] Values;

 public static IEnumerable&lt;TKey&gt; Keys
 {
 get { return Enum.GetValues(typeof (TKey)).OfType&lt;TKey&gt;(); }
 }

 public T this[TKey index]
 {
 get { return Values[Convert.ToInt32(index)]; }
 set { Values[Convert.ToInt32(index)] = value; }
 }

 private IEnumerable&lt;KeyValuePair&lt;TKey, T&gt;&gt; CreateEnumerable()
 {
 return Keys.Select(key =&gt; new KeyValuePair&lt;TKey, T&gt;(key, Values[Convert.ToInt32(key)]));
 }

 public IEnumerator&lt;KeyValuePair&lt;TKey, T&gt;&gt; GetEnumerator()
 {
 return CreateEnumerable().GetEnumerator();
 }

 IEnumerator IEnumerable.GetEnumerator()
 {
 return GetEnumerator();
 }
 }
</code></pre>

So in your case you could derive:

<pre><code>class DaysOfWeekToStringsMap:EnumIndexedArray&lt;DayOfWeek,string&gt;{};
</code></pre>

Usage:

<pre><code>var map = new DaysOfWeekToStringsMap();

//using the Keys static property
foreach(var day in DaysOfWeekToStringsMap.Keys){
 map[day] = day.ToString();
}
foreach(var day in DaysOfWeekToStringsMap.Keys){
 Console.WriteLine("map[{0}]={1}",day, map[day]);
}

// using iterator
foreach(var value in map){
 Console.WriteLine("map[{0}]={1}",value.Key, value.Value);
}
</code></pre>

Obviously this implementation is backed by an array, so non-contiguous enums like this:

<pre><code>enum
{
 Ok = 1,
 NotOk = 1000000
}
</code></pre>

would result in excessive memory usage.

If you require maximum possible performance you might want to make it less generic and loose all generic enum handling code I had to use to get it to compile and work. I didn't benchmark this though, so maybe it's no big deal.

Caching the Keys static property might also help.

blocks|key|1317743|text|以上问题可概括如下，以供日后参考：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317744|我来自Delphi，您可以按如下方式定义数组：|1317745|type
++{$SCOPEDENUMS+ON}
++TDaysOfTheWeek+=+(Monday,+Tuesday,+Wednesday,+Thursday,+Friday,+Saturday,+Sunday);

++TDaysOfTheWeekStrings+=+array[TDaysOfTheWeek];|code-block|syntax|javascript|1317746|然后可以使用Min和Max遍历数组：|1317747|for+Dow+:=+Min(TDaysOfTheWeek)+to+Max(TDaysOfTheWeek)+
++DaysOfTheWeekStrings[Dow]+:=+'';|1317748|尽管这是一个人为的例子，但是在代码后面处理数组位置时，我可以直接输入DaysOfTheWeekStrings[TDaysOfTheWeek.Monday]。这样做的好处是，如果TDaysOfTheWeek的大小增加了，那么我就不必记住数组的新大小了。然而，回到C#的世界。我找到了这个例子C#+Enum+Array+Example。|offset|length|style|CODE|1317749|entityMap|0|LINK|mutability|MUTABLE|url|http://www.dotnetperls.com/enum-array^0|0|0|0|0|0|Y|17|2G|E|40|L|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@$O|16|P|17|Q|R]|$O|18|P|19|Q|R]]|9|@$O|1A|P|1B|1|1C]]|A|$]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

For future reference the above problem can be summarized as follows: 

I come from Delphi where you can define an array as follows:

<pre><code>type
 {$SCOPEDENUMS ON}
 TDaysOfTheWeek = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

 TDaysOfTheWeekStrings = array[TDaysOfTheWeek];
</code></pre>

Then you can iterate through the array using Min and Max:

<pre><code>for Dow := Min(TDaysOfTheWeek) to Max(TDaysOfTheWeek) 
 DaysOfTheWeekStrings[Dow] := '';
</code></pre>

Though this is quite a contrived example, when you are dealing with array positions later in the code I can just type <code>DaysOfTheWeekStrings[TDaysOfTheWeek.Monday]</code>. This has the advantage of the fact that I should the <code>TDaysOfTheWeek</code> increase in size then I do not have to remember the new size of the array etc..... However back to the C# world. I have found this example <a href="http://www.dotnetperls.com/enum-array" rel="nofollow noreferrer">C# Enum Array Example</a>.

blocks|key|1533082|text|我意识到这是一个古老的问题，但有许多评论认为，到目前为止，所有解决方案都有运行时检查，以确保数据类型是枚举。这里有一个完整的解决方案(包括一些示例)，它带有编译时检查(以及我的开发同事的一些评论和讨论)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1533083|//There+is+no+good+way+to+constrain+a+generic+class+parameter+to+an+Enum.++The+hack+below+does+work+at+compile+time,
//++though+it+is+convoluted.++For+examples+of+how+to+use+the+two+classes+EnumIndexedArray+and+ObjEnumIndexedArray,
//++see+AssetClassArray+below.++Or,+e.g.
//++++++EConstraint.EnumIndexedArray<int,+YourEnum>+x+=+new+EConstraint.EnumIndexedArray<int,+YourEnum>();
//++See+this+post+
//++++++http://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum/29581813#29581813
//+and+the+answer/comments+by+Julien+Lebosquain
public+class+EConstraint+:+HackForCompileTimeConstraintOfTEnumToAnEnum<System.Enum>+{+}//THIS+MUST+BE+THE+ONLY+IMPLEMENTATION+OF+THE+ABSTRACT+HackForCompileTimeConstraintOfTEnumToAnEnum
public+abstract+class+HackForCompileTimeConstraintOfTEnumToAnEnum<SystemEnum>+where+SystemEnum+:+class
{
++++//For+object+types+T,+users+should+use+EnumIndexedObjectArray+below.
++++public+class+EnumIndexedArray<T,+TEnum>
++++++++where+TEnum+:+struct,+SystemEnum
++++{
++++++++//Needs+to+be+public+so+that+we+can+easily+do+things+like+intIndexedArray.data.sum()
++++++++//+++-+just+not+worth+writing+up+all+the+equivalent+methods,+and+we+can't+inherit+from+T[]+and+guarantee+proper+initialization.
++++++++//Also,+note+that+we+cannot+use+Length+here+for+initialization,+even+if+Length+were+defined+the+same+as+GetNumEnums+up+to
++++++++//++static+qualification,+because+we+cannot+use+a+non-static+for+initialization+here.
++++++++//++Since+we+want+Length+to+be+non-static,+in+keeping+with+other+definitions+of+the+Length+property,+we+define+the+separate+static
++++++++//++GetNumEnums,+and+then+define+the+non-static+Length+in+terms+of+the+actual+size+of+the+data+array,+just+for+clarity,
++++++++//++safety+and+certainty+(in+case+someone+does+something+stupid+like+resizing+data).
++++++++public+T[]+data+=+new+T[GetNumEnums()];

++++++++//First,+a+couple+of+statics+allowing+easy+use+of+the+enums+themselves.
++++++++public+static+TEnum[]+GetEnums()
++++++++{
++++++++++++return+(TEnum[])Enum.GetValues(typeof(TEnum));
++++++++}
++++++++public+TEnum[]+getEnums()
++++++++{
++++++++++++return+GetEnums();
++++++++}
++++++++//Provide+a+static+method+of+getting+the+number+of+enums.++The+Length+property+also+returns+this,+but+it+is+not+static+and+cannot+be+use+in+many+circumstances.
++++++++public+static+int+GetNumEnums()
++++++++{
++++++++++++return+GetEnums().Length;
++++++++}
++++++++//This+should+always+return+the+same+as+GetNumEnums,+but+is+not+static+and+does+it+in+a+way+that+guarantees+consistency+with+the+member+array.
++++++++public+int+Length+{+get+{+return+data.Length;+}+}
++++++++//public+int+Count++{+get+{+return+data.Length;+}+}

++++++++public+EnumIndexedArray()+{+}

++++++++//+[WDS+2015-04-17]+Remove.+This+can+be+dangerous.+Just+force+people+to+use+EnumIndexedArray(T[]+inputArray).
++++++++//+[DIM+2015-04-18]+Actually,+if+you+think+about+it,+EnumIndexedArray(T[]+inputArray)+is+just+as+dangerous:
++++++++//+++For+value+types,+both+are+fine.++For+object+types,+the+latter+causes+each+object+in+the+input+array+to+be+referenced+twice,
++++++++//+++while+the+former+causes+the+single+object+t+to+be+multiply+referenced.++Two+references+to+each+of+many+is+no+less+dangerous
++++++++//+++than+3+or+more+references+to+one.+So+all+of+these+are+dangerous+for+object+types.
++++++++//+++We+could+remove+all+these+ctors+from+this+base+class,+and+create+a+separate
++++++++//+++++++++EnumIndexedValueArray<T,+TEnum>+:+EnumIndexedArray<T,+TEnum>+where+T:+struct+...
++++++++//+++but+then+specializing+to+TEnum+=+AssetClass+would+have+to+be+done+twice+below,+once+for+value+types+and+once
++++++++//+++for+object+types,+with+a+repetition+of+all+the+property+definitions.++Violating+the+DRY+principle+that+much
++++++++//+++just+to+protect+against+stupid+usage,+clearly+documented+as+dangerous,+is+not+worth+it+IMHO.
++++++++public+EnumIndexedArray(T+t)
++++++++{
++++++++++++int+i+=+Length;
++++++++++++while+(--i+>=+0)
++++++++++++{
++++++++++++++++this[i]+=+t;
++++++++++++}
++++++++}
++++++++public+EnumIndexedArray(T[]+inputArray)
++++++++{
++++++++++++if+(inputArray.Length+>+Length)
++++++++++++{
++++++++++++++++throw+new+Exception(string.Format("Length+of+enum-indexed+array+({0})+to+big.+Can't+be+more+than+{1}.",+inputArray.Length,+Length));
++++++++++++}
++++++++++++Array.Copy(inputArray,+data,+inputArray.Length);
++++++++}
++++++++public+EnumIndexedArray(EnumIndexedArray<T,+TEnum>+inputArray)
++++++++{
++++++++++++Array.Copy(inputArray.data,+data,+data.Length);
++++++++}

++++++++//Clean+data+access
++++++++public+T+this[int+ac]+{+get+{+return+data[ac];+}+set+{+data[ac]+=+value;+}+}
++++++++public+T+this[TEnum+ac]+{+get+{+return+data[Convert.ToInt32(ac)];+}+set+{+data[Convert.ToInt32(ac)]+=+value;+}+}
++++}


++++public+class+EnumIndexedObjectArray<T,+TEnum>+:+EnumIndexedArray<T,+TEnum>
++++++++where+TEnum+:+struct,+SystemEnum
++++++++where+T+:+new()
++++{
++++++++public+EnumIndexedObjectArray(bool+doInitializeWithNewObjects+=+true)
++++++++{
++++++++++++if+(doInitializeWithNewObjects)
++++++++++++{
++++++++++++++++for+(int+i+=+Length;+i+>+0;+this[--i]+=+new+T())+;
++++++++++++}
++++++++}
++++++++//+The+other+ctor's+are+dangerous+for+object+arrays
++++}

++++public+class+EnumIndexedArrayComparator<T,+TEnum>+:+EqualityComparer<EnumIndexedArray<T,+TEnum>>
++++++++where+TEnum+:+struct,+SystemEnum
++++{
++++++++private+readonly+EqualityComparer<T>+elementComparer+=+EqualityComparer<T>.Default;

++++++++public+override+bool+Equals(EnumIndexedArray<T,+TEnum>+lhs,+EnumIndexedArray<T,+TEnum>+rhs)
++++++++{
++++++++++++if+(lhs+==+rhs)
++++++++++++++++return+true;
++++++++++++if+(lhs+==+null+%7C%7C+rhs+==+null)
++++++++++++++++return+false;

++++++++++++//These+cases+should+not+be+possible+because+of+the+way+these+classes+are+constructed.
++++++++++++//+HOWEVER,+the+data+member+is+public,+so+somebody+_could_+do+something+stupid+and+make+
++++++++++++//+data=null,+or+make+lhs.data+==+rhs.data,+even+though+lhs!=rhs+(above+check)
++++++++++++//On+the+other+hand,+these+are+just+optimizations,+so+it+won't+be+an+issue+if+we+reomve+them+anyway,
++++++++++++//+Unless+someone+does+something+really+dumb+like+setting+.data+to+null+or+resizing+to+an+incorrect+size,
++++++++++++//+in+which+case+things+will+crash,+but+any+developer+who+does+this+deserves+to+have+it+crash+painfully...
++++++++++++//if+(lhs.data+==+rhs.data)
++++++++++++//++++return+true;
++++++++++++//if+(lhs.data+==+null+%7C%7C+rhs.data+==+null)
++++++++++++//++++return+false;

++++++++++++int+i+=+lhs.Length;
++++++++++++//if+(rhs.Length+!=+i)
++++++++++++//++++return+false;
++++++++++++while+(--i+>=+0)
++++++++++++{
++++++++++++++++if+(!elementComparer.Equals(lhs[i],+rhs[i]))
++++++++++++++++++++return+false;
++++++++++++}
++++++++++++return+true;
++++++++}
++++++++public+override+int+GetHashCode(EnumIndexedArray<T,+TEnum>+enumIndexedArray)
++++++++{
++++++++++++//This+doesn't+work:+for+two+arrays+ar1+and+ar2,+ar1.GetHashCode()+!=+ar2.GetHashCode()+even+when+ar1[i]==ar2[i]+for+all+i+(unless+of+course+they+are+the+exact+same+array+object)
++++++++++++//return+engineArray.GetHashCode();
++++++++++++//Code+taken+from+comment+by+Jon+Skeet+-+of+course+-+in+http://stackoverflow.com/questions/7244699/gethashcode-on-byte-array
++++++++++++//31+and+17+are+used+commonly+elsewhere,+but+maybe+because+everyone+is+using+Skeet's+post.
++++++++++++//On+the+other+hand,+this+is+really+not+very+critical.
++++++++++++unchecked
++++++++++++{
++++++++++++++++int+hash+=+17;
++++++++++++++++int+i+=+enumIndexedArray.Length;
++++++++++++++++while+(--i+>=+0)
++++++++++++++++{
++++++++++++++++++++hash+=+hash+*+31+%2B+elementComparer.GetHashCode(enumIndexedArray[i]);
++++++++++++++++}
++++++++++++++++return+hash;
++++++++++++}
++++++++}
++++}
}

//Because+of+the+above+hack,+this+fails+at+compile+time+-+as+it+should.++It+would,+otherwise,+only+fail+at+run+time.
//public+class+ThisShouldNotCompile+:+EConstraint.EnumIndexedArray<int,+bool>
//{
//}

//An+example
public+enum+AssetClass+{+Ir,+FxFwd,+Cm,+Eq,+FxOpt,+Cr+};
public+class+AssetClassArrayComparator<T>+:+EConstraint.EnumIndexedArrayComparator<T,+AssetClass>+{+}
public+class+AssetClassIndexedArray<T>+:+EConstraint.EnumIndexedArray<T,+AssetClass>
{
++++public+AssetClassIndexedArray()
++++{
++++}
++++public+AssetClassIndexedArray(T+t)+:+base(t)
++++{
++++}
++++public+AssetClassIndexedArray(T[]+inputArray)+:++base(inputArray)
++++{
++++}
++++public+AssetClassIndexedArray(EConstraint.EnumIndexedArray<T,+AssetClass>+inputArray)+:+base(inputArray)
++++{
++++}

++++public+T+Cm++++{+get+{+return+this[AssetClass.Cm+++];+}+set+{+this[AssetClass.Cm+++]+=+value;+}+}
++++public+T+FxFwd+{+get+{+return+this[AssetClass.FxFwd];+}+set+{+this[AssetClass.FxFwd]+=+value;+}+}
++++public+T+Ir++++{+get+{+return+this[AssetClass.Ir+++];+}+set+{+this[AssetClass.Ir+++]+=+value;+}+}
++++public+T+Eq++++{+get+{+return+this[AssetClass.Eq+++];+}+set+{+this[AssetClass.Eq+++]+=+value;+}+}
++++public+T+FxOpt+{+get+{+return+this[AssetClass.FxOpt];+}+set+{+this[AssetClass.FxOpt]+=+value;+}+}
++++public+T+Cr++++{+get+{+return+this[AssetClass.Cr+++];+}+set+{+this[AssetClass.Cr+++]+=+value;+}+}
}

//Inherit+from+AssetClassArray<T>,+not+EnumIndexedObjectArray<T,+AssetClass>,+so+we+get+the+benefit+of+the+public+access+getters+and+setters+above
public+class+AssetClassIndexedObjectArray<T>+:+AssetClassIndexedArray<T>+where+T+:+new()
{
++++public+AssetClassIndexedObjectArray(bool+bInitializeWithNewObjects+=+true)
++++{
++++++++if+(bInitializeWithNewObjects)
++++++++{
++++++++++++for+(int+i+=+Length;+i+>+0;+this[--i]+=+new+T())+;
++++++++}
++++}
}|code-block|syntax|javascript|1533084|编辑:如果您使用的是C#+7.3或更高版本，请不要使用这个丑陋的解决方案。参见Ian+Goldby在2018年的回答。|1533085|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I realize this is an old question, but there have been a number of comments about the fact that all solutions so far have run-time checks to ensure the data type is an enum. Here is a complete solution (with some examples) of a solution with compile time checks (as well as some comments and discussions from my fellow developers)

<pre><code>//There is no good way to constrain a generic class parameter to an Enum. The hack below does work at compile time,
// though it is convoluted. For examples of how to use the two classes EnumIndexedArray and ObjEnumIndexedArray,
// see AssetClassArray below. Or, e.g.
// EConstraint.EnumIndexedArray&lt;int, YourEnum&gt; x = new EConstraint.EnumIndexedArray&lt;int, YourEnum&gt;();
// See this post 
// http://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum/29581813#29581813
// and the answer/comments by Julien Lebosquain
public class EConstraint : HackForCompileTimeConstraintOfTEnumToAnEnum&lt;System.Enum&gt; { }//THIS MUST BE THE ONLY IMPLEMENTATION OF THE ABSTRACT HackForCompileTimeConstraintOfTEnumToAnEnum
public abstract class HackForCompileTimeConstraintOfTEnumToAnEnum&lt;SystemEnum&gt; where SystemEnum : class
{
 //For object types T, users should use EnumIndexedObjectArray below.
 public class EnumIndexedArray&lt;T, TEnum&gt;
 where TEnum : struct, SystemEnum
 {
 //Needs to be public so that we can easily do things like intIndexedArray.data.sum()
 // - just not worth writing up all the equivalent methods, and we can't inherit from T[] and guarantee proper initialization.
 //Also, note that we cannot use Length here for initialization, even if Length were defined the same as GetNumEnums up to
 // static qualification, because we cannot use a non-static for initialization here.
 // Since we want Length to be non-static, in keeping with other definitions of the Length property, we define the separate static
 // GetNumEnums, and then define the non-static Length in terms of the actual size of the data array, just for clarity,
 // safety and certainty (in case someone does something stupid like resizing data).
 public T[] data = new T[GetNumEnums()];

 //First, a couple of statics allowing easy use of the enums themselves.
 public static TEnum[] GetEnums()
 {
 return (TEnum[])Enum.GetValues(typeof(TEnum));
 }
 public TEnum[] getEnums()
 {
 return GetEnums();
 }
 //Provide a static method of getting the number of enums. The Length property also returns this, but it is not static and cannot be use in many circumstances.
 public static int GetNumEnums()
 {
 return GetEnums().Length;
 }
 //This should always return the same as GetNumEnums, but is not static and does it in a way that guarantees consistency with the member array.
 public int Length { get { return data.Length; } }
 //public int Count { get { return data.Length; } }

 public EnumIndexedArray() { }

 // [WDS 2015-04-17] Remove. This can be dangerous. Just force people to use EnumIndexedArray(T[] inputArray).
 // [DIM 2015-04-18] Actually, if you think about it, EnumIndexedArray(T[] inputArray) is just as dangerous:
 // For value types, both are fine. For object types, the latter causes each object in the input array to be referenced twice,
 // while the former causes the single object t to be multiply referenced. Two references to each of many is no less dangerous
 // than 3 or more references to one. So all of these are dangerous for object types.
 // We could remove all these ctors from this base class, and create a separate
 // EnumIndexedValueArray&lt;T, TEnum&gt; : EnumIndexedArray&lt;T, TEnum&gt; where T: struct ...
 // but then specializing to TEnum = AssetClass would have to be done twice below, once for value types and once
 // for object types, with a repetition of all the property definitions. Violating the DRY principle that much
 // just to protect against stupid usage, clearly documented as dangerous, is not worth it IMHO.
 public EnumIndexedArray(T t)
 {
 int i = Length;
 while (--i &gt;= 0)
 {
 this[i] = t;
 }
 }
 public EnumIndexedArray(T[] inputArray)
 {
 if (inputArray.Length &gt; Length)
 {
 throw new Exception(string.Format("Length of enum-indexed array ({0}) to big. Can't be more than {1}.", inputArray.Length, Length));
 }
 Array.Copy(inputArray, data, inputArray.Length);
 }
 public EnumIndexedArray(EnumIndexedArray&lt;T, TEnum&gt; inputArray)
 {
 Array.Copy(inputArray.data, data, data.Length);
 }

 //Clean data access
 public T this[int ac] { get { return data[ac]; } set { data[ac] = value; } }
 public T this[TEnum ac] { get { return data[Convert.ToInt32(ac)]; } set { data[Convert.ToInt32(ac)] = value; } }
 }


 public class EnumIndexedObjectArray&lt;T, TEnum&gt; : EnumIndexedArray&lt;T, TEnum&gt;
 where TEnum : struct, SystemEnum
 where T : new()
 {
 public EnumIndexedObjectArray(bool doInitializeWithNewObjects = true)
 {
 if (doInitializeWithNewObjects)
 {
 for (int i = Length; i &gt; 0; this[--i] = new T()) ;
 }
 }
 // The other ctor's are dangerous for object arrays
 }

 public class EnumIndexedArrayComparator&lt;T, TEnum&gt; : EqualityComparer&lt;EnumIndexedArray&lt;T, TEnum&gt;&gt;
 where TEnum : struct, SystemEnum
 {
 private readonly EqualityComparer&lt;T&gt; elementComparer = EqualityComparer&lt;T&gt;.Default;

 public override bool Equals(EnumIndexedArray&lt;T, TEnum&gt; lhs, EnumIndexedArray&lt;T, TEnum&gt; rhs)
 {
 if (lhs == rhs)
 return true;
 if (lhs == null || rhs == null)
 return false;

 //These cases should not be possible because of the way these classes are constructed.
 // HOWEVER, the data member is public, so somebody _could_ do something stupid and make 
 // data=null, or make lhs.data == rhs.data, even though lhs!=rhs (above check)
 //On the other hand, these are just optimizations, so it won't be an issue if we reomve them anyway,
 // Unless someone does something really dumb like setting .data to null or resizing to an incorrect size,
 // in which case things will crash, but any developer who does this deserves to have it crash painfully...
 //if (lhs.data == rhs.data)
 // return true;
 //if (lhs.data == null || rhs.data == null)
 // return false;

 int i = lhs.Length;
 //if (rhs.Length != i)
 // return false;
 while (--i &gt;= 0)
 {
 if (!elementComparer.Equals(lhs[i], rhs[i]))
 return false;
 }
 return true;
 }
 public override int GetHashCode(EnumIndexedArray&lt;T, TEnum&gt; enumIndexedArray)
 {
 //This doesn't work: for two arrays ar1 and ar2, ar1.GetHashCode() != ar2.GetHashCode() even when ar1[i]==ar2[i] for all i (unless of course they are the exact same array object)
 //return engineArray.GetHashCode();
 //Code taken from comment by Jon Skeet - of course - in http://stackoverflow.com/questions/7244699/gethashcode-on-byte-array
 //31 and 17 are used commonly elsewhere, but maybe because everyone is using Skeet's post.
 //On the other hand, this is really not very critical.
 unchecked
 {
 int hash = 17;
 int i = enumIndexedArray.Length;
 while (--i &gt;= 0)
 {
 hash = hash * 31 + elementComparer.GetHashCode(enumIndexedArray[i]);
 }
 return hash;
 }
 }
 }
}

//Because of the above hack, this fails at compile time - as it should. It would, otherwise, only fail at run time.
//public class ThisShouldNotCompile : EConstraint.EnumIndexedArray&lt;int, bool&gt;
//{
//}

//An example
public enum AssetClass { Ir, FxFwd, Cm, Eq, FxOpt, Cr };
public class AssetClassArrayComparator&lt;T&gt; : EConstraint.EnumIndexedArrayComparator&lt;T, AssetClass&gt; { }
public class AssetClassIndexedArray&lt;T&gt; : EConstraint.EnumIndexedArray&lt;T, AssetClass&gt;
{
 public AssetClassIndexedArray()
 {
 }
 public AssetClassIndexedArray(T t) : base(t)
 {
 }
 public AssetClassIndexedArray(T[] inputArray) : base(inputArray)
 {
 }
 public AssetClassIndexedArray(EConstraint.EnumIndexedArray&lt;T, AssetClass&gt; inputArray) : base(inputArray)
 {
 }

 public T Cm { get { return this[AssetClass.Cm ]; } set { this[AssetClass.Cm ] = value; } }
 public T FxFwd { get { return this[AssetClass.FxFwd]; } set { this[AssetClass.FxFwd] = value; } }
 public T Ir { get { return this[AssetClass.Ir ]; } set { this[AssetClass.Ir ] = value; } }
 public T Eq { get { return this[AssetClass.Eq ]; } set { this[AssetClass.Eq ] = value; } }
 public T FxOpt { get { return this[AssetClass.FxOpt]; } set { this[AssetClass.FxOpt] = value; } }
 public T Cr { get { return this[AssetClass.Cr ]; } set { this[AssetClass.Cr ] = value; } }
}

//Inherit from AssetClassArray&lt;T&gt;, not EnumIndexedObjectArray&lt;T, AssetClass&gt;, so we get the benefit of the public access getters and setters above
public class AssetClassIndexedObjectArray&lt;T&gt; : AssetClassIndexedArray&lt;T&gt; where T : new()
{
 public AssetClassIndexedObjectArray(bool bInitializeWithNewObjects = true)
 {
 if (bInitializeWithNewObjects)
 {
 for (int i = Length; i &gt; 0; this[--i] = new T()) ;
 }
 }
}
</code></pre>

EDIT:
If you are using C# 7.3 or later, PLEASE don't use this ugly solution. See Ian Goldby's answer from 2018.

blocks|key|1533161|text|从C#+7.3开始，就可以使用System.Enum+as+a+constraint+on+type+parameters了。因此，不再需要其他一些答案中令人讨厌的黑客攻击。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1533162|下面是一个非常简单的ArrayByEum类，它准确地完成了所提出的问题。|1533163|注意，如果枚举值不是连续的，那么它将浪费空间，并且不能处理对于int来说太大的枚举值。我确实说过这个例子非常简单。|1533164|///+<summary>An+array+indexed+by+an+Enum</summary>
///+<typeparam+name="T">Type+stored+in+array</typeparam>
///+<typeparam+name="U">Indexer+Enum+type</typeparam>
public+class+ArrayByEnum<T,U>+:+IEnumerable+where+U+:+Enum+//+requires+C#+7.3+or+later
{
++private+readonly+T[]+_array;
++private+readonly+int+_lower;

++public+ArrayByEnum()
++{
++++_lower+=+Convert.ToInt32(Enum.GetValues(typeof(U)).Cast().Min());
++++int+upper+=+Convert.ToInt32(Enum.GetValues(typeof(U)).Cast().Max());
++++_array+=+new+T[1+%2B+upper+-+_lower];
++}

++public+T+this[U+key]
++{
++++get+{+return+_array[Convert.ToInt32(key)+-+_lower];+}
++++set+{+_array[Convert.ToInt32(key)+-+_lower]+=+value;+}
++}

++public+IEnumerator+GetEnumerator()
++{
++++return+Enum.GetValues(typeof(U)).Cast().Select(i+=>+this[i]).GetEnumerator();
++}
}|code-block|syntax|javascript|1533165|用法：|1533166|ArrayByEnum<string,MyEnum>+myArray+=+new+ArrayByEnum<string,MyEnum>();
myArray[MyEnum.First]+=+"Hello";

myArray[YourEnum.Other]+=+"World";+//+compiler+error|1533167|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-3#enhanced-generic-constraints^0|F|B|F|1A|0|0|A|A|0|V|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1C|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1D|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1E|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

Since C# 7.3 it has been possible to use <a href="https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-3#enhanced-generic-constraints" rel="noreferrer"><code>System.Enum</code> as a constraint on type parameters</a>. So the nasty hacks in the some of the other answers are no longer required.

Here's a very simple <code>ArrayByEum</code> class that does exactly what the question asked.

Note that it will waste space if the enum values are non-contiguous, and won't cope with enum values that are too large for an <code>int</code>. I did say this example was very simple.

<pre><code>/// &lt;summary&gt;An array indexed by an Enum&lt;/summary&gt;
/// &lt;typeparam name="T"&gt;Type stored in array&lt;/typeparam&gt;
/// &lt;typeparam name="U"&gt;Indexer Enum type&lt;/typeparam&gt;
public class ArrayByEnum&lt;T,U&gt; : IEnumerable where U : Enum // requires C# 7.3 or later
{
 private readonly T[] _array;
 private readonly int _lower;

 public ArrayByEnum()
 {
 _lower = Convert.ToInt32(Enum.GetValues(typeof(U)).Cast&lt;U&gt;().Min());
 int upper = Convert.ToInt32(Enum.GetValues(typeof(U)).Cast&lt;U&gt;().Max());
 _array = new T[1 + upper - _lower];
 }

 public T this[U key]
 {
 get { return _array[Convert.ToInt32(key) - _lower]; }
 set { _array[Convert.ToInt32(key) - _lower] = value; }
 }

 public IEnumerator GetEnumerator()
 {
 return Enum.GetValues(typeof(U)).Cast&lt;U&gt;().Select(i =&gt; this[i]).GetEnumerator();
 }
}
</code></pre>

Usage:

<pre><code>ArrayByEnum&lt;string,MyEnum&gt; myArray = new ArrayByEnum&lt;string,MyEnum&gt;();
myArray[MyEnum.First] = "Hello";

myArray[YourEnum.Other] = "World"; // compiler error
</code></pre>

blocks|key|1533251|text|这是@ian-goldby的一个非常好的答案，但它没有解决@zar-shardan提出的问题，这是我自己提出的问题。下面是我对一个解决方案的看法，其中包含一个用于转换IEnumerable的扩展类和一个下面的测试类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1533252|///+<summary>
///+An+array+indexed+by+an+enumerated+type+instead+of+an+integer
///+</summary>
public+class+ArrayIndexedByEnum<TKey,+TElement>+:+IEnumerable<TElement>+where+TKey+:+Enum
{
++private+readonly+Array+_array;
++private+readonly+Dictionary<TKey,+TElement>+_dictionary;

++///+<summary>
++///+Creates+the+initial+array,+populated+with+the+defaults+for+TElement
++///+</summary>
++public+ArrayIndexedByEnum()
++{
++++var+min+=+Convert.ToInt64(Enum.GetValues(typeof(TKey)).Cast<TKey>().Min());
++++var+max+=+Convert.ToInt64(Enum.GetValues(typeof(TKey)).Cast<TKey>().Max());
++++var+size+=+max+-+min+%2B+1;

++++//+Check+that+we+aren't+creating+a+ridiculously+big+array,+if+we+are,
++++//+then+use+a+dictionary+instead
++++if+(min+>=+Int32.MinValue+&&+
++++++++max+<=+Int32.MaxValue+&&+
++++++++size+<+Enum.GetValues(typeof(TKey)).Length+*+3L)
++++{
++++++var+lowerBound+=+Convert.ToInt32(min);
++++++var+upperBound+=+Convert.ToInt32(max);
++++++_array+=+Array.CreateInstance(typeof(TElement),+new+int[]+{(int)size+},+new+int[]+{+lowerBound+});
++++}
++++else
++++{
++++++_dictionary+=+new+Dictionary<TKey,+TElement>();
++++++foreach+(var+value+in+Enum.GetValues(typeof(TKey)).Cast<TKey>())
++++++{
++++++++_dictionary[value]+=+default(TElement);
++++++}
++++}
++}

++///+<summary>
++///+Gets+the+element+by+enumerated+type
++///+</summary>
++public+TElement+this[TKey+key]
++{
++++get+=>+(TElement)(_array?.GetValue(Convert.ToInt32(key))+??+_dictionary[key]);
++++set
++++{
++++++if+(_array+!=+null)
++++++{
++++++++_array.SetValue(value,+Convert.ToInt32(key));
++++++}
++++++else
++++++{
++++++++_dictionary[key]+=+value;
++++++}
++++}
++}

++///+<summary>
++///+Gets+a+generic+enumerator
++///+</summary>
++public+IEnumerator<TElement>+GetEnumerator()
++{
++++return+Enum.GetValues(typeof(TKey)).Cast<TKey>().Select(k+=>+this[k]).GetEnumerator();
++}

++System.Collections.IEnumerator+System.Collections.IEnumerable.GetEnumerator()
++{
++++return+GetEnumerator();
++}
}|code-block|syntax|javascript|1533253|下面是扩展类：|1533254|///+<summary>
///+Extensions+for+converting+IEnumerable<TElement>+to+ArrayIndexedByEnum
///+</summary>
public+static+class+ArrayIndexedByEnumExtensions
{
++///+<summary>
++///+Creates+a+ArrayIndexedByEnumExtensions+from+an+System.Collections.Generic.IEnumerable
++///+according+to+specified+key+selector+and+element+selector+functions.
++///+</summary>
++public+static+ArrayIndexedByEnum<TKey,+TElement>+ToArrayIndexedByEnum<TSource,+TKey,+TElement>(this+IEnumerable<TSource>+source,+Func<TSource,+TKey>+keySelector,+Func<TSource,+TElement>+elementSelector)+where+TKey+:+Enum
++{
++++var+array+=+new+ArrayIndexedByEnum<TKey,+TElement>();
++++foreach(var+item+in+source)
++++{
++++++array[keySelector(item)]+=+elementSelector(item);
++++}
++++return+array;
++}
++///+<summary>
++///+Creates+a+ArrayIndexedByEnum+from+an+System.Collections.Generic.IEnumerable
++///+according+to+a+specified+key+selector+function.
++///+</summary>
++public+static+ArrayIndexedByEnum<TKey,+TSource>+ToArrayIndexedByEnum<TSource,+TKey>(this+IEnumerable<TSource>+source,+Func<TSource,+TKey>+keySelector)+where+TKey+:+Enum
++{
++++return+source.ToArrayIndexedByEnum(keySelector,+i+=>+i);
++}
}|1533255|下面是我的测试：|1533256|[TestClass]
public+class+ArrayIndexedByEnumUnitTest
{
++private+enum+OddNumbersEnum+:+UInt16
++{
++++One+=+1,
++++Three+=+3,
++++Five+=+5,
++++Seven+=+7,
++++Nine+=+9
++}

++private+enum+PowersOf2+:+Int64
++{
++++TwoP0+=+1,
++++TwoP1+=+2,
++++TwoP2+=+4,
++++TwoP3+=+8,
++++TwoP4+=+16,
++++TwoP5+=+32,
++++TwoP6+=+64,
++++TwoP7+=+128,
++++TwoP8+=+256,
++++TwoP9+=+512,
++++TwoP10+=+1_024,
++++TwoP11+=+2_048,
++++TwoP12+=+4_096,
++++TwoP13+=+8_192,
++++TwoP14+=+16_384,
++++TwoP15+=+32_768,
++++TwoP16+=+65_536,
++++TwoP17+=+131_072,
++++TwoP18+=+262_144,
++++TwoP19+=+524_288,
++++TwoP20+=+1_048_576,
++++TwoP21+=+2_097_152,
++++TwoP22+=+4_194_304,
++++TwoP23+=+8_388_608,
++++TwoP24+=+16_777_216,
++++TwoP25+=+33_554_432,
++++TwoP26+=+67_108_864,
++++TwoP27+=+134_217_728,
++++TwoP28+=+268_435_456,
++++TwoP29+=+536_870_912,
++++TwoP30+=+1_073_741_824,
++++TwoP31+=+2_147_483_648,
++++TwoP32+=+4_294_967_296,
++++TwoP33+=+8_589_934_592,
++++TwoP34+=+17_179_869_184,
++++TwoP35+=+34_359_738_368,
++++TwoP36+=+68_719_476_736,
++++TwoP37+=+137_438_953_472,
++++TwoP38+=+274_877_906_944,
++++TwoP39+=+549_755_813_888,
++++TwoP40+=+1_099_511_627_776,
++++TwoP41+=+2_199_023_255_552,
++++TwoP42+=+4_398_046_511_104,
++++TwoP43+=+8_796_093_022_208,
++++TwoP44+=+17_592_186_044_416,
++++TwoP45+=+35_184_372_088_832,
++++TwoP46+=+70_368_744_177_664,
++++TwoP47+=+140_737_488_355_328,
++++TwoP48+=+281_474_976_710_656,
++++TwoP49+=+562_949_953_421_312,
++++TwoP50+=+1_125_899_906_842_620,
++++TwoP51+=+2_251_799_813_685_250,
++++TwoP52+=+4_503_599_627_370_500,
++++TwoP53+=+9_007_199_254_740_990,
++++TwoP54+=+18_014_398_509_482_000,
++++TwoP55+=+36_028_797_018_964_000,
++++TwoP56+=+72_057_594_037_927_900,
++++TwoP57+=+144_115_188_075_856_000,
++++TwoP58+=+288_230_376_151_712_000,
++++TwoP59+=+576_460_752_303_423_000,
++++TwoP60+=+1_152_921_504_606_850_000,
++}

++[TestMethod]
++public+void+TestSimpleArray()
++{
++++var+array+=+new+ArrayIndexedByEnum<OddNumbersEnum,+string>();

++++var+odds+=+Enum.GetValues(typeof(OddNumbersEnum)).Cast<OddNumbersEnum>().ToList();

++++//+Store+all+the+values
++++foreach+(var+odd+in+odds)
++++{
++++++array[odd]+=+odd.ToString();
++++}

++++//+Check+the+retrieved+values+are+the+same+as+what+was+stored
++++foreach+(var+odd+in+odds)
++++{
++++++Assert.AreEqual(odd.ToString(),+array[odd]);
++++}
++}

++[TestMethod]
++public+void+TestPossiblyHugeArray()
++{
++++var+array+=+new+ArrayIndexedByEnum<PowersOf2,+string>();

++++var+powersOf2s+=+Enum.GetValues(typeof(PowersOf2)).Cast<PowersOf2>().ToList();

++++//+Store+all+the+values
++++foreach+(var+powerOf2+in+powersOf2s)
++++{
++++++array[powerOf2]+=+powerOf2.ToString();
++++}

++++//+Check+the+retrieved+values+are+the+same+as+what+was+stored
++++foreach+(var+powerOf2+in+powersOf2s)
++++{
++++++Assert.AreEqual(powerOf2.ToString(),+array[powerOf2]);
++++}
++}
}|1533257|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

It was a very good answer by @ian-goldby, but it didn't address the issue raised by @zar-shardan, which is an issue I hit myself. Below is my take on a solution, with a an extension class for converting an IEnumerable, and a test class below that:
<pre class="lang-cs prettyprint-override"><code>/// &lt;summary&gt;
/// An array indexed by an enumerated type instead of an integer
/// &lt;/summary&gt;
public class ArrayIndexedByEnum&lt;TKey, TElement&gt; : IEnumerable&lt;TElement&gt; where TKey : Enum
{
 private readonly Array _array;
 private readonly Dictionary&lt;TKey, TElement&gt; _dictionary;

 /// &lt;summary&gt;
 /// Creates the initial array, populated with the defaults for TElement
 /// &lt;/summary&gt;
 public ArrayIndexedByEnum()
 {
 var min = Convert.ToInt64(Enum.GetValues(typeof(TKey)).Cast&lt;TKey&gt;().Min());
 var max = Convert.ToInt64(Enum.GetValues(typeof(TKey)).Cast&lt;TKey&gt;().Max());
 var size = max - min + 1;

 // Check that we aren't creating a ridiculously big array, if we are,
 // then use a dictionary instead
 if (min &gt;= Int32.MinValue &amp;&amp; 
 max &lt;= Int32.MaxValue &amp;&amp; 
 size &lt; Enum.GetValues(typeof(TKey)).Length * 3L)
 {
 var lowerBound = Convert.ToInt32(min);
 var upperBound = Convert.ToInt32(max);
 _array = Array.CreateInstance(typeof(TElement), new int[] {(int)size }, new int[] { lowerBound });
 }
 else
 {
 _dictionary = new Dictionary&lt;TKey, TElement&gt;();
 foreach (var value in Enum.GetValues(typeof(TKey)).Cast&lt;TKey&gt;())
 {
 _dictionary[value] = default(TElement);
 }
 }
 }

 /// &lt;summary&gt;
 /// Gets the element by enumerated type
 /// &lt;/summary&gt;
 public TElement this[TKey key]
 {
 get =&gt; (TElement)(_array?.GetValue(Convert.ToInt32(key)) ?? _dictionary[key]);
 set
 {
 if (_array != null)
 {
 _array.SetValue(value, Convert.ToInt32(key));
 }
 else
 {
 _dictionary[key] = value;
 }
 }
 }

 /// &lt;summary&gt;
 /// Gets a generic enumerator
 /// &lt;/summary&gt;
 public IEnumerator&lt;TElement&gt; GetEnumerator()
 {
 return Enum.GetValues(typeof(TKey)).Cast&lt;TKey&gt;().Select(k =&gt; this[k]).GetEnumerator();
 }

 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 {
 return GetEnumerator();
 }
}
</code></pre>
Here's the extension class:
<pre class="lang-cs prettyprint-override"><code>/// &lt;summary&gt;
/// Extensions for converting IEnumerable&lt;TElement&gt; to ArrayIndexedByEnum
/// &lt;/summary&gt;
public static class ArrayIndexedByEnumExtensions
{
 /// &lt;summary&gt;
 /// Creates a ArrayIndexedByEnumExtensions from an System.Collections.Generic.IEnumerable
 /// according to specified key selector and element selector functions.
 /// &lt;/summary&gt;
 public static ArrayIndexedByEnum&lt;TKey, TElement&gt; ToArrayIndexedByEnum&lt;TSource, TKey, TElement&gt;(this IEnumerable&lt;TSource&gt; source, Func&lt;TSource, TKey&gt; keySelector, Func&lt;TSource, TElement&gt; elementSelector) where TKey : Enum
 {
 var array = new ArrayIndexedByEnum&lt;TKey, TElement&gt;();
 foreach(var item in source)
 {
 array[keySelector(item)] = elementSelector(item);
 }
 return array;
 }
 /// &lt;summary&gt;
 /// Creates a ArrayIndexedByEnum from an System.Collections.Generic.IEnumerable
 /// according to a specified key selector function.
 /// &lt;/summary&gt;
 public static ArrayIndexedByEnum&lt;TKey, TSource&gt; ToArrayIndexedByEnum&lt;TSource, TKey&gt;(this IEnumerable&lt;TSource&gt; source, Func&lt;TSource, TKey&gt; keySelector) where TKey : Enum
 {
 return source.ToArrayIndexedByEnum(keySelector, i =&gt; i);
 }
}
</code></pre>
And here are my tests:
<pre class="lang-cs prettyprint-override"><code>[TestClass]
public class ArrayIndexedByEnumUnitTest
{
 private enum OddNumbersEnum : UInt16
 {
 One = 1,
 Three = 3,
 Five = 5,
 Seven = 7,
 Nine = 9
 }

 private enum PowersOf2 : Int64
 {
 TwoP0 = 1,
 TwoP1 = 2,
 TwoP2 = 4,
 TwoP3 = 8,
 TwoP4 = 16,
 TwoP5 = 32,
 TwoP6 = 64,
 TwoP7 = 128,
 TwoP8 = 256,
 TwoP9 = 512,
 TwoP10 = 1_024,
 TwoP11 = 2_048,
 TwoP12 = 4_096,
 TwoP13 = 8_192,
 TwoP14 = 16_384,
 TwoP15 = 32_768,
 TwoP16 = 65_536,
 TwoP17 = 131_072,
 TwoP18 = 262_144,
 TwoP19 = 524_288,
 TwoP20 = 1_048_576,
 TwoP21 = 2_097_152,
 TwoP22 = 4_194_304,
 TwoP23 = 8_388_608,
 TwoP24 = 16_777_216,
 TwoP25 = 33_554_432,
 TwoP26 = 67_108_864,
 TwoP27 = 134_217_728,
 TwoP28 = 268_435_456,
 TwoP29 = 536_870_912,
 TwoP30 = 1_073_741_824,
 TwoP31 = 2_147_483_648,
 TwoP32 = 4_294_967_296,
 TwoP33 = 8_589_934_592,
 TwoP34 = 17_179_869_184,
 TwoP35 = 34_359_738_368,
 TwoP36 = 68_719_476_736,
 TwoP37 = 137_438_953_472,
 TwoP38 = 274_877_906_944,
 TwoP39 = 549_755_813_888,
 TwoP40 = 1_099_511_627_776,
 TwoP41 = 2_199_023_255_552,
 TwoP42 = 4_398_046_511_104,
 TwoP43 = 8_796_093_022_208,
 TwoP44 = 17_592_186_044_416,
 TwoP45 = 35_184_372_088_832,
 TwoP46 = 70_368_744_177_664,
 TwoP47 = 140_737_488_355_328,
 TwoP48 = 281_474_976_710_656,
 TwoP49 = 562_949_953_421_312,
 TwoP50 = 1_125_899_906_842_620,
 TwoP51 = 2_251_799_813_685_250,
 TwoP52 = 4_503_599_627_370_500,
 TwoP53 = 9_007_199_254_740_990,
 TwoP54 = 18_014_398_509_482_000,
 TwoP55 = 36_028_797_018_964_000,
 TwoP56 = 72_057_594_037_927_900,
 TwoP57 = 144_115_188_075_856_000,
 TwoP58 = 288_230_376_151_712_000,
 TwoP59 = 576_460_752_303_423_000,
 TwoP60 = 1_152_921_504_606_850_000,
 }

 [TestMethod]
 public void TestSimpleArray()
 {
 var array = new ArrayIndexedByEnum&lt;OddNumbersEnum, string&gt;();

 var odds = Enum.GetValues(typeof(OddNumbersEnum)).Cast&lt;OddNumbersEnum&gt;().ToList();

 // Store all the values
 foreach (var odd in odds)
 {
 array[odd] = odd.ToString();
 }

 // Check the retrieved values are the same as what was stored
 foreach (var odd in odds)
 {
 Assert.AreEqual(odd.ToString(), array[odd]);
 }
 }

 [TestMethod]
 public void TestPossiblyHugeArray()
 {
 var array = new ArrayIndexedByEnum&lt;PowersOf2, string&gt;();

 var powersOf2s = Enum.GetValues(typeof(PowersOf2)).Cast&lt;PowersOf2&gt;().ToList();

 // Store all the values
 foreach (var powerOf2 in powersOf2s)
 {
 array[powerOf2] = powerOf2.ToString();
 }

 // Check the retrieved values are the same as what was stored
 foreach (var powerOf2 in powersOf2s)
 {
 Assert.AreEqual(powerOf2.ToString(), array[powerOf2]);
 }
 }
}
</code></pre>

I want to do the same as in <a href="https://stackoverflow.com/questions/404231/using-an-enum-as-an-array-index">this question</a>, that is:

<pre><code>enum DaysOfTheWeek {Sunday=0, Monday, Tuesday...};
string[] message_array = new string[number_of_items_at_enum];

...

Console.Write(custom_array[(int)DaysOfTheWeek.Sunday]);
</code></pre>

however, I would rather have something integral to so, rather than write this error prone code. Is there a built in module in C# that does just this?

Using an enum as an array index in C#

我想执行与相同的操作，即：enum DaysOfTheWeek {Sunday=0, Monday, Tuesday...};string[] message_array = new string[number_of_items_at_enum];...Console.Write(custom_array[(int)D...

问在C#中使用枚举作为数组索引
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中使用枚举作为数组索引EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中使用枚举作为数组索引
EN