blocks|key|360948|text|在C#中创建真正的编译时生成的常量字典并不是一项简单的任务。实际上，这里没有一个答案能真正做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360949|不过，有一个解决方案可以满足您的需求，尽管不一定是一个很好的解决方案；请记住，根据C#规范，切换情况表被编译为常量散列跳转表。也就是说，它们是常量字典，而不是一系列if-else语句。因此，考虑下面这样的switch-case语句：|360950|switch+(myString)
{
+++case+"cat":+return+0;
+++case+"dog":+return+1;
+++case+"elephant":+return+3;
}|code-block|syntax|javascript|360951|这正是你想要的。是的，我知道，这很丑陋。|360952|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Creating a truly compile-time generated constant dictionary in C# is not really a straightforward task. Actually, none of the answers here really achieve that.

There is one solution though which meets your requirements, although not necessarily a nice one; remember that according to the C# specification, switch-case tables are compiled to constant hash jump tables. That is, they are constant dictionaries, not a series of if-else statements. So consider a switch-case statement like this:

<pre><code>switch (myString)
{
 case "cat": return 0;
 case "dog": return 1;
 case "elephant": return 3;
}
</code></pre>

This is exactly what you want. And yes, I know, it's ugly.

blocks|key|360940|text|在当前的框架中，几乎没有不可变的集合。在.NET+3.5中，我能想到一个相对轻松的选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360941|使用Enumerable.ToLookup()+-+Lookup<,>类是不可变的(但在rhs上是多值的)；您可以在Dictionary<,>中很容易地做到这一点：|offset|length|style|CODE|360942|++++Dictionary<string,+int>+ids+=+new+Dictionary<string,+int>+{
++++++{"abc",1},+{"def",2},+{"ghi",3}
++++};
++++ILookup<string,+int>+lookup+=+ids.ToLookup(x+=>+x.Key,+x+=>+x.Value);
++++int+i+=+lookup["def"].Single();|code-block|syntax|javascript|360943|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb460184.aspx^0|0|2|L|Q|9|1M|D|Q|9|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]]|9|@$D|12|E|13|1|14]]|A|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

There are precious few immutable collections in the current framework. I can think of one relatively pain-free option in .NET 3.5:

Use <code>Enumerable.ToLookup()</code> - the <a href="http://msdn.microsoft.com/en-us/library/bb460184.aspx" rel="noreferrer"><code>Lookup&lt;,&gt;</code></a> class is immutable (but multi-valued on the rhs); you can do this from a <code>Dictionary&lt;,&gt;</code> quite easily:

<pre><code> Dictionary&lt;string, int&gt; ids = new Dictionary&lt;string, int&gt; {
 {"abc",1}, {"def",2}, {"ghi",3}
 };
 ILookup&lt;string, int&gt; lookup = ids.ToLookup(x =&gt; x.Key, x =&gt; x.Value);
 int i = lookup["def"].Single();
</code></pre>

blocks|key|360945|text|enum+Constants
{
++++Abc+=+1,
++++Def+=+2,
++++Ghi+=+3
}

...

int+i+=+(int)Enum.Parse(typeof(Constants),+"Def");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|360946|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>enum Constants
{
 Abc = 1,
 Def = 2,
 Ghi = 3
}

...

int i = (int)Enum.Parse(typeof(Constants), "Def");
</code></pre>

blocks|key|3357180|text|这是你能找到的最接近"CONST字典“的东西了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3357181|public+static+int+GetValueByName(string+name)
{
++++switch+(name)
++++{
++++++++case+"bob":+return+1;
++++++++case+"billy":+return+2;
++++++++default:+return+-1;
++++}
}|code-block|syntax|javascript|3357182|编译器将足够智能地构建尽可能干净的代码。|3357183|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|$]]

This is the closest thing you can get to a "CONST Dictionary":

<pre><code>public static int GetValueByName(string name)
{
 switch (name)
 {
 case "bob": return 1;
 case "billy": return 2;
 default: return -1;
 }
}
</code></pre>

The compiler will be smart enough to build the code as clean as possible.

blocks|key|3357216|text|如果使用4.5%2B框架，我会使用ReadOnlyDictionary+(也可以是列表的ReadOnly集合)来执行只读映射/常量。它是通过以下方式实现的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3357217|static+class+SomeClass
{
++++static+readonly+ReadOnlyDictionary<string,int>+SOME_MAPPING+
++++++++=+new+ReadOnlyDictionary<string,int>(
++++++++++++new+Dictionary<string,int>()
++++++++++++{
++++++++++++++++{+"One",+1+},
++++++++++++++++{+"Two",+2+}
++++++++++++}
++++++++)
}++++++++|code-block|syntax|javascript|3357218|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|$]]

If using 4.5+ Framework I would use ReadOnlyDictionary (also ReadOnly Collection for lists) to do readonly mappings/constants. It's implemented in the following way.

<pre><code>static class SomeClass
{
 static readonly ReadOnlyDictionary&lt;string,int&gt; SOME_MAPPING 
 = new ReadOnlyDictionary&lt;string,int&gt;(
 new Dictionary&lt;string,int&gt;()
 {
 { "One", 1 },
 { "Two", 2 }
 }
 )
} 
</code></pre>

blocks|key|360983|text|我不知道为什么没有人提到这一点，但在C#中，对于我不能赋值常量的东西，我使用静态只读属性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360984|示例：|360985|public+static+readonly+Dictionary<string,+string[]>+NewDictionary+=+new+Dictionary<string,+string[]>()
++++++++{
++++++++++++{+"Reference1",+Array1+},
++++++++++++{+"Reference2",+Array2+},
++++++++++++{+"Reference3",+Array3+},
++++++++++++{+"Reference4",+Array4+},
++++++++++++{+"Reference5",+Array5+}
++++++++};|code-block|syntax|javascript|360986|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I am not sure why no one mentioned this but in C# for things that I cannot assign const, I use static read-only properties.

Example:

<pre><code>public static readonly Dictionary&lt;string, string[]&gt; NewDictionary = new Dictionary&lt;string, string[]&gt;()
 {
 { "Reference1", Array1 },
 { "Reference2", Array2 },
 { "Reference3", Array3 },
 { "Reference4", Array4 },
 { "Reference5", Array5 }
 };
</code></pre>

blocks|key|357558|text|为什么不使用名称空间或类来嵌套您的值呢？它可能不完美，但它是非常干净的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357559|public+static+class+ParentClass
{
++++//+here+is+the+"dictionary"+class
++++public+static+class+FooDictionary
++++{
++++++++public+const+string+Key1+=+"somevalue";
++++++++public+const+string+Foobar+=+"fubar";
++++}
}|code-block|syntax|javascript|357560|现在您可以访问.ParentClass.FooDictionary.Key1等。|357561|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|$]]

Why not use namespaces or classes to nest your values? It may be imperfect, but it is very clean.

<pre><code>public static class ParentClass
{
 // here is the "dictionary" class
 public static class FooDictionary
 {
 public const string Key1 = "somevalue";
 public const string Foobar = "fubar";
 }
}
</code></pre>

Now you can access .ParentClass.FooDictionary.Key1, etc.

blocks|key|3144364|text|对于字典，似乎没有任何标准的不可变接口，所以不幸的是，创建包装器似乎是唯一合理的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144365|Dictionary编辑：Marc+Gravell找到了我遗漏的ILookup+--这将使您至少避免创建新的包装器，尽管您仍然需要使用.ToLookup()转换。|offset|length|style|BOLD|3144366|如果这是一个特定场景的需求，那么您最好使用一个更面向业务逻辑的接口：|3144367|interface+IActiveUserCountProvider
{
++++int+GetMaxForServer(string+serverName);
}|code-block|syntax|javascript|3144368|entityMap^0|0|28|1|0|0|Y|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

There does not seem to be any standard immutable interface for dictionaries, so creating a wrapper seems like the only reasonable option, unfortunately.

Edit: Marc Gravell found the ILookup that I missed - that will allow you to at least avoid creating a new wrapper, although you still need to transform the Dictionary with .ToLookup().

If this is a need constrained to a specific scenario, you might be better off with a more business-logic-oriented interface:

<pre><code>interface IActiveUserCountProvider
{
 int GetMaxForServer(string serverName);
}
</code></pre>

blocks|key|3144545|text|这只是另一个想法，因为我绑定到了winforms组合框：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144546|public+enum+DateRange+{
++++[Display(Name+=+"None")]
++++None+=+0,
++++[Display(Name+=+"Today")]
++++Today+=+1,
++++[Display(Name+=+"Tomorrow")]
++++Tomorrow+=+2,
++++[Display(Name+=+"Yesterday")]
++++Yesterday+=+3,
++++[Display(Name+=+"Last+7+Days")]
++++LastSeven+=+4,
++++[Display(Name+=+"Custom")]
++++Custom+=+99
++++};

int+something+=+(int)DateRange.None;|code-block|syntax|javascript|3144547|从显示名称from获取int值|offset|length|3144548|public+static+class+EnumHelper<T>
{
++++public+static+T+GetValueFromName(string+name)
++++{
++++++++var+type+=+typeof(T);
++++++++if+(!type.IsEnum)+throw+new+InvalidOperationException();

++++++++foreach+(var+field+in+type.GetFields())
++++++++{
++++++++++++var+attribute+=+Attribute.GetCustomAttribute(field,
++++++++++++++++typeof(DisplayAttribute))+as+DisplayAttribute;
++++++++++++if+(attribute+!=+null)
++++++++++++{
++++++++++++++++if+(attribute.Name+==+name)
++++++++++++++++{
++++++++++++++++++++return+(T)field.GetValue(null);
++++++++++++++++}
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++if+(field.Name+==+name)
++++++++++++++++++++return+(T)field.GetValue(null);
++++++++++++}
++++++++}

++++++++throw+new+ArgumentOutOfRangeException("name");
++++}
}|3144549|用法：|3144550|var+z+=+(int)EnumHelper<DateRange>.GetValueFromName("Last+7+Days");|3144551|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/33225729/enum-value-from-display-name^0|0|0|5|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@$I|11|J|12|1|13]]|A|$]]|$1|K|3|L|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Just another idea since I am binding to a winforms combobox:

<pre><code>public enum DateRange {
 [Display(Name = "None")]
 None = 0,
 [Display(Name = "Today")]
 Today = 1,
 [Display(Name = "Tomorrow")]
 Tomorrow = 2,
 [Display(Name = "Yesterday")]
 Yesterday = 3,
 [Display(Name = "Last 7 Days")]
 LastSeven = 4,
 [Display(Name = "Custom")]
 Custom = 99
 };

int something = (int)DateRange.None;
</code></pre>

To get the int value from the display name <a href="https://stackoverflow.com/questions/33225729/enum-value-from-display-name">from</a>:

<pre><code>public static class EnumHelper&lt;T&gt;
{
 public static T GetValueFromName(string name)
 {
 var type = typeof(T);
 if (!type.IsEnum) throw new InvalidOperationException();

 foreach (var field in type.GetFields())
 {
 var attribute = Attribute.GetCustomAttribute(field,
 typeof(DisplayAttribute)) as DisplayAttribute;
 if (attribute != null)
 {
 if (attribute.Name == name)
 {
 return (T)field.GetValue(null);
 }
 }
 else
 {
 if (field.Name == name)
 return (T)field.GetValue(null);
 }
 }

 throw new ArgumentOutOfRangeException("name");
 }
}
</code></pre>

usage:

<pre><code>var z = (int)EnumHelper&lt;DateRange&gt;.GetValueFromName("Last 7 Days");
</code></pre>

blocks|key|3144570|text|从C#+8开始，new+switch+expression是实现这一目标的最干净的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3144571|int+value+=+inputString+switch+{
++++"one"+=>+1,
++++"two"+=>+2,
++++_+=>+-1
};|code-block|syntax|javascript|3144572|或者作为一个函数|3144573|int+GetValue(string+inputString)+=>+inputString+switch+{
++++"one"+=>+1,
++++"two"+=>+2,
++++_+=>+-1
};|3144574|它比“旧的”更简洁：|3144575|int+value+=+-1;
switch+(inputString){
++++case+"one":+value=1;+break;
++++case+"two":+value=2;+break;
}|3144576|在不同的编译器中，新旧版本的性能差异可能会有所不同。|3144577|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/switch-expression^0|8|L|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

As of C# 8, the <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/switch-expression" rel="nofollow noreferrer">new switch expression</a> is the cleanest way to achieve the result:
<pre><code>int value = inputString switch {
 &quot;one&quot; =&gt; 1,
 &quot;two&quot; =&gt; 2,
 _ =&gt; -1
};
</code></pre>
or as a function
<pre><code>int GetValue(string inputString) =&gt; inputString switch {
 &quot;one&quot; =&gt; 1,
 &quot;two&quot; =&gt; 2,
 _ =&gt; -1
};
</code></pre>
It is more concise that the &quot;old&quot; one:
<pre><code>int value = -1;
switch (inputString){
 case &quot;one&quot;: value=1; break;
 case &quot;two&quot;: value=2; break;
}
</code></pre>
The difference in performance of the old and new one can vary across different compilers

blocks|key|358291|text|为什么不呢：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|358292|public+class+MyClass
{
++++private+Dictionary<string,+int>+_myCollection+=+new+Dictionary<string,+int>()+{+{+"A",+1+},+{+"B",+2+},+{+"C",+3+}+};

++++public+IEnumerable<KeyValuePair<string,int>>+MyCollection
++++{
++++++++get+{+return+_myCollection.AsEnumerable<KeyValuePair<string,+int>>();+}
++++}
}|code-block|syntax|javascript|358293|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|$]]

Why not:

<pre><code>public class MyClass
{
 private Dictionary&lt;string, int&gt; _myCollection = new Dictionary&lt;string, int&gt;() { { "A", 1 }, { "B", 2 }, { "C", 3 } };

 public IEnumerable&lt;KeyValuePair&lt;string,int&gt;&gt; MyCollection
 {
 get { return _myCollection.AsEnumerable&lt;KeyValuePair&lt;string, int&gt;&gt;(); }
 }
}</code></pre>

What is the most efficient way to create a constant (never changes at runtime) mapping of <code>string</code>s to <code>int</code>s? 

I've tried using a <a href="https://stackoverflow.com/questions/268064/c-how-can-dictionarykv-implement-icollectionkeyvaluepairkv-without-having-addke">const Dictionary</a>, but that didn't work out. 

I could implement a <a href="https://stackoverflow.com/questions/35002/does-c-have-a-way-of-giving-me-an-immutable-dictionary">immutable wrapper</a> with appropriate semantics, but that still doesn't seem totally right.

<hr>

For those who have asked, I'm implementing <a href="https://msdn.microsoft.com/en-us/library/system.componentmodel.idataerrorinfo(v=vs.110).aspx" rel="noreferrer">IDataErrorInfo</a> in a generated class and am looking for a way to make the columnName lookup into my array of descriptors. 

I wasn't aware (typo when testing! d'oh!) that switch accepts strings, so that's what I'm gonna use. Thanks!

Creating a constant Dictionary in C#

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

创建从strings到ints的常量(在运行时从不更改)映射的最有效方法是什么？我试过使用，但不起作用。我可以用适当的语义实现一个，但这看起来仍然不完全正确。如果有人问起，我将在一个生成的类中实现，并且正在寻找一种方法来在我的描述符数组中进行columnName查找。我没有意识到(测试时拼写错误！哦！)该开关接受字符串，所以这就是我要使用的。谢谢!

问在C#中创建常量字典
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中创建常量字典EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中创建常量字典
EN