blocks|key|1785385|text|你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1785386|string[]+temp+=+new+string[mydict.count];
mydict.Keys.CopyTo(temp,+0)
int+LastCount+=+mydict[temp[mydict.count+-+1]]|code-block|syntax|javascript|1785387|但我不建议你这么做。不能保证最后插入的键会在数组的末尾。密钥on+MSDN的排序未指定，可能会更改。在我非常简短的测试中，它似乎是按插入顺序排列的，但如果只需要知道最新的键，最好像您建议的那样在适当的记账中构建堆栈(尽管我不认为需要基于其他语句的结构)或单变量缓存。|offset|length|1785388|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2.keys^0|0|0|U|7|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

You could always do this:

<pre><code>string[] temp = new string[mydict.count];
mydict.Keys.CopyTo(temp, 0)
int LastCount = mydict[temp[mydict.count - 1]]
</code></pre>

But I wouldn't recommend it. There's no guarantee that the last inserted key will be at the end of the array. The ordering for Keys <a href="https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2.keys" rel="nofollow noreferrer">on MSDN</a> is unspecified, and subject to change. In my very brief test, it does seem to be in order of insertion, but you'd be better off building in proper bookkeeping like a stack--as you suggest (though I don't see the need of a struct based on your other statements)--or single variable cache if you just need to know the latest key.

blocks|key|1785460|text|我不知道这是否有效，因为我非常确定键不是按添加顺序存储的，但您可以将KeysCollection转换为列表，然后获取列表中的最后一个键……但这是值得一看的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1785461|我唯一能想到的另一件事是将键存储在查找列表中，并在将键添加到字典之前将其添加到列表中……虽然不是很好。|1785462|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I don't know if this would work because I'm pretty sure that the keys aren't stored in the order they are added, but you could cast the KeysCollection to a List and then get the last key in the list... but it would be worth having a look.

The only other thing I can think of is to store the keys in a lookup list and add the keys to the list before you add them to the dictionary... it's not pretty tho.

blocks|key|1785542|text|我认为你可以这样做，语法可能是错误的，有一段时间没有使用C#来获取最后一项了|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1785543|Dictionary<string,+int>.KeyCollection+keys+=+mydict.keys;
string+lastKey+=+keys.Last();|code-block|syntax|javascript|1785544|或者使用Max而不是Last来获得最大值，我不知道哪个更适合您的代码。|1785545|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 think you can do something like this, the syntax might be wrong, havent used C# in a while
To get the last item

<pre><code>Dictionary&lt;string, int&gt;.KeyCollection keys = mydict.keys;
string lastKey = keys.Last();
</code></pre>

or use Max instead of Last to get the max value, I dont know which one fits your code better.

blocks|key|1785598|text|我同意帕特里克的答案的第二部分。即使在某些测试中它似乎保持了插入顺序，文档(以及字典和散列的正常行为)也明确指出了顺序是未指定的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1785599|根据密钥的顺序，您只是在自找麻烦。添加您自己的记账(正如Patrick所说，最后添加的密钥只有一个变量)以确保。此外，不要被字典上的Last和Max等所有方法所诱惑，因为这些方法可能与键比较器有关(我不太确定)。|1785600|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I agree with the second part of Patrick's answer. Even if in some tests it seems to keep insertion order, the documentation (and normal behavior for dictionaries and hashes) explicitly states the ordering is unspecified.

You're just asking for trouble depending on the ordering of the keys. Add your own bookkeeping (as Patrick said, just a single variable for the last added key) to be sure. Also, don't be tempted by all the methods such as Last and Max on the dictionary as those are probably in relation to the key comparator (I'm not sure about that).

blocks|key|1785665|text|你的问题表达方式让我相信字典中的int包含了条目在字典中的“位置”。根据键没有按添加顺序存储的断言判断，如果这是正确的，这将意味着keys.Count+(或.Count+-+1，如果您使用从零开始)仍然应该始终是最后输入的键的编号？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1785666|如果这是正确的，有什么原因你不能使用Dictionary，这样你就可以使用mydict+mydict.Keys.Count了|1785667|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The way you worded the question leads me to believe that the int in the Dictionary contains the item's "position" on the Dictionary. Judging from the assertion that the keys aren't stored in the order that they're added, if this is correct, that would mean that keys.Count (or .Count - 1, if you're using zero-based) should still always be the number of the last-entered key?

If that's correct, is there any reason you can't instead use Dictionary&lt;int, string&gt; so that you can use mydict[ mydict.Keys.Count ]?

blocks|key|1570770|text|为什么不简单地扩展字典类，添加最后一个键插入的属性。可能是下面这样的内容？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1570771|public+class+ExtendedDictionary+:+Dictionary<string,+int>
{
++++private+int+lastKeyInserted+=+-1;

++++public+int+LastKeyInserted
++++{
++++++++get+{+return+lastKeyInserted;+}
++++++++set+{+lastKeyInserted+=+value;+}
++++}

++++public+void+AddNew(string+s,+int+i)
++++{
++++++++lastKeyInserted+=+i;

++++++++base.Add(s,+i);
++++}
}|code-block|syntax|javascript|1570772|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 don't you just extend the dictionary class to add in a last key inserted property. Something like the following maybe?

<pre><code>public class ExtendedDictionary : Dictionary&lt;string, int&gt;
{
 private int lastKeyInserted = -1;

 public int LastKeyInserted
 {
 get { return lastKeyInserted; }
 set { lastKeyInserted = value; }
 }

 public void AddNew(string s, int i)
 {
 lastKeyInserted = i;

 base.Add(s, i);
 }
}
</code></pre>

blocks|key|1785781|text|字典是一个哈希表，所以你不知道插入的顺序！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1785782|如果您想知道最后插入的键，我建议扩展字典，使其包含一个LastKeyInserted值。|1785783|例如：|1785784|public+MyDictionary<K,+T>+:+IDictionary<K,+T>
{
++++private+IDictionary<K,+T>+_InnerDictionary;

++++public+K+LastInsertedKey+{+get;+set;+}

++++public+MyDictionary()
++++{
++++++++_InnerDictionary+=+new+Dictionary<K,+T>();
++++}

++++#region+Implementation+of+IDictionary

++++public+void+Add(KeyValuePair<K,+T>+item)
++++{
++++++++_InnerDictionary.Add(item);
++++++++LastInsertedKey+=+item.Key;

++++}

++++public+void+Add(K+key,+T+value)
++++{
++++++++_InnerDictionary.Add(key,+value);
++++++++LastInsertedKey+=+key;
++++}

++++....+rest+of+IDictionary+methods

++++#endregion

}|code-block|syntax|javascript|1785785|但是，当您使用.Remove()时会遇到问题，因此要克服这个问题，您必须保持所插入的键的有序列表。|offset|length|style|CODE|1785786|entityMap^0|0|0|0|0|7|9|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

A Dictionary is a Hash Table, so you have no idea the order of insertion!

If you want to know the last inserted key I would suggest extending the Dictionary to include a LastKeyInserted value.

E.g.:

<pre><code>public MyDictionary&lt;K, T&gt; : IDictionary&lt;K, T&gt;
{
 private IDictionary&lt;K, T&gt; _InnerDictionary;

 public K LastInsertedKey { get; set; }

 public MyDictionary()
 {
 _InnerDictionary = new Dictionary&lt;K, T&gt;();
 }

 #region Implementation of IDictionary

 public void Add(KeyValuePair&lt;K, T&gt; item)
 {
 _InnerDictionary.Add(item);
 LastInsertedKey = item.Key;

 }

 public void Add(K key, T value)
 {
 _InnerDictionary.Add(key, value);
 LastInsertedKey = key;
 }

 .... rest of IDictionary methods

 #endregion

}
</code></pre>

You will run into problems however when you use <code>.Remove()</code> so to overcome this you will have to keep an ordered list of the keys inserted.

blocks|key|1570932|text|如果您决定使用易被破坏的危险代码，此扩展函数将根据其内部索引从Dictionary<K,V>中获取一个键(对于Mono和.NET，当前的顺序似乎与您通过枚举Keys属性获得的顺序相同)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1570933|最好使用Linq：dict.Keys.ElementAt(i)，但该函数将迭代O(N)；下面是O(1)，但会带来反射性能损失。|1570934|using+System;
using+System.Collections.Generic;
using+System.Reflection;

public+static+class+Extensions
{
++++public+static+TKey+KeyByIndex<TKey,TValue>(this+Dictionary<TKey,+TValue>+dict,+int+idx)
++++{
++++++++Type+type+=+typeof(Dictionary<TKey,+TValue>);
++++++++FieldInfo+info+=+type.GetField("entries",+BindingFlags.NonPublic+%7C+BindingFlags.Instance);
++++++++if+(info+!=+null)
++++++++{
++++++++++++//+.NET
++++++++++++Object+element+=+((Array)info.GetValue(dict)).GetValue(idx);
++++++++++++return+(TKey)element.GetType().GetField("key",+BindingFlags.Public+%7C+BindingFlags.Instance).GetValue(element);
++++++++}
++++++++//+Mono:
++++++++info+=+type.GetField("keySlots",+BindingFlags.NonPublic+%7C+BindingFlags.Instance);
++++++++return+(TKey)((Array)info.GetValue(dict)).GetValue(idx);
++++}
};|code-block|syntax|javascript|1570935|entityMap^0|V|F|26|4|0|9|M|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

In case you decide to use dangerous code that is subject to breakage, this extension function will fetch a key from a <code>Dictionary&lt;K,V&gt;</code> according to its internal indexing (which for Mono and .NET currently appears to be in the same order as you get by enumerating the <code>Keys</code> property).

It is much preferable to use Linq: <code>dict.Keys.ElementAt(i)</code>, but that function will iterate O(N); the following is O(1) but with a reflection performance penalty.

<pre><code>using System;
using System.Collections.Generic;
using System.Reflection;

public static class Extensions
{
 public static TKey KeyByIndex&lt;TKey,TValue&gt;(this Dictionary&lt;TKey, TValue&gt; dict, int idx)
 {
 Type type = typeof(Dictionary&lt;TKey, TValue&gt;);
 FieldInfo info = type.GetField("entries", BindingFlags.NonPublic | BindingFlags.Instance);
 if (info != null)
 {
 // .NET
 Object element = ((Array)info.GetValue(dict)).GetValue(idx);
 return (TKey)element.GetType().GetField("key", BindingFlags.Public | BindingFlags.Instance).GetValue(element);
 }
 // Mono:
 info = type.GetField("keySlots", BindingFlags.NonPublic | BindingFlags.Instance);
 return (TKey)((Array)info.GetValue(dict)).GetValue(idx);
 }
};
</code></pre>

blocks|key|1571039|text|如果键嵌入在值中，一种替代方法是KeyedCollection。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1571040|只需在密封类中创建一个基本实现即可使用。|1571041|所以要替换Dictionary<string,+int>+(这不是一个很好的例子，因为没有明确的整数键)。|style|CODE|1571042|private+sealed+class+IntDictionary+:+KeyedCollection<string,+int>
{
++++protected+override+string+GetKeyForItem(int+item)
++++{
++++++++//+The+example+works+better+when+the+value+contains+the+key.+It+falls+down+a+bit+for+a+dictionary+of+ints.
++++++++return+item.ToString();
++++}
}

KeyedCollection<string,+int>+intCollection+=+new+ClassThatContainsSealedImplementation.IntDictionary();

intCollection.Add(7);

int+valueByIndex+=+intCollection[0];|code-block|syntax|javascript|1571043|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.collections.objectmodel.keyedcollection-2^0|G|F|0|0|0|5|N|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|11|8|@$A|12|B|13|H|I]]|9|@]|C|$]]|$1|J|3|K|5|L|7|14|8|@]|9|@]|C|$M|N]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

One alternative would be a <a href="https://docs.microsoft.com/en-us/dotnet/api/system.collections.objectmodel.keyedcollection-2" rel="nofollow noreferrer">KeyedCollection</a> if the key is embedded in the value.

Just create a basic implementation in a sealed class to use.

So to replace <code>Dictionary&lt;string, int&gt;</code> (which isn't a very good example as there isn't a clear key for a int).

<pre><code>private sealed class IntDictionary : KeyedCollection&lt;string, int&gt;
{
 protected override string GetKeyForItem(int item)
 {
 // The example works better when the value contains the key. It falls down a bit for a dictionary of ints.
 return item.ToString();
 }
}

KeyedCollection&lt;string, int&gt; intCollection = new ClassThatContainsSealedImplementation.IntDictionary();

intCollection.Add(7);

int valueByIndex = intCollection[0];
</code></pre>

blocks|key|1571142|text|为了扩展Daniels的帖子和他关于键的评论，由于键无论如何都嵌入在值中，您可以求助于使用KeyValuePair<TKey,+TValue>作为值。这样做的主要原因是，通常情况下，键不一定可以直接从值派生。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1571143|然后它看起来就像这样：|1571144|public+sealed+class+CustomDictionary<TKey,+TValue>
++:+KeyedCollection<TKey,+KeyValuePair<TKey,+TValue>>
{
++protected+override+TKey+GetKeyForItem(KeyValuePair<TKey,+TValue>+item)
++{
++++return+item.Key;
++}
}|code-block|syntax|javascript|1571145|要像前面的示例一样使用它，您需要执行以下操作：|1571146|CustomDictionary<string,+int>+custDict+=+new+CustomDictionary<string,+int>();

custDict.Add(new+KeyValuePair<string,+int>("key",+7));

int+valueByIndex+=+custDict[0].Value;
int+valueByKey+=+custDict["key"].Value;
string+keyByIndex+=+custDict[0].Key;|1571147|entityMap^0|19|Q|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

To expand on Daniels post and his comments regarding the key, since the key is embedded within the value anyway, you could resort to using a <code>KeyValuePair&lt;TKey, TValue&gt;</code> as the value. The main reasoning for this is that, in general, the Key isn't necessarily directly derivable from the value.

Then it'd look like this:

<pre><code>public sealed class CustomDictionary&lt;TKey, TValue&gt;
 : KeyedCollection&lt;TKey, KeyValuePair&lt;TKey, TValue&gt;&gt;
{
 protected override TKey GetKeyForItem(KeyValuePair&lt;TKey, TValue&gt; item)
 {
 return item.Key;
 }
}
</code></pre>

To use this as in the previous example, you'd do:

<pre><code>CustomDictionary&lt;string, int&gt; custDict = new CustomDictionary&lt;string, int&gt;();

custDict.Add(new KeyValuePair&lt;string, int&gt;("key", 7));

int valueByIndex = custDict[0].Value;
int valueByKey = custDict["key"].Value;
string keyByIndex = custDict[0].Key;
</code></pre>

blocks|key|1786153|text|您也可以使用SortedList和它的泛型副本。这两个类和Andrew+Peters+answer中提到的OrderedDictionary都是字典类，其中的条目可以通过索引(位置)和键进行访问。如何使用这些类你可以找到：SortedList+Class，SortedList+Generic+Class。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1786154|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.collections.sortedlist|1|https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.sortedlist-2^0|33|G|0|3K|O|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

You can also use SortedList and its Generic counterpart. These two classes and in Andrew Peters answer mentioned OrderedDictionary are dictionary classes in which items can be accessed by index (position) as well as by key. How to use these classes you can find: <a href="https://docs.microsoft.com/en-us/dotnet/api/system.collections.sortedlist" rel="nofollow noreferrer">SortedList Class</a> , <a href="https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.sortedlist-2" rel="nofollow noreferrer">SortedList Generic Class</a> .

blocks|key|1786257|text|Visual+Studio的UserVoice提供了一个通过dotmore链接到generic+OrderedDictionary+implementation的链接。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1786258|但是，如果您只需要通过索引获取键/值对，而不需要通过键获取值，则可以使用一个简单的技巧。声明一些泛型类(我称之为ListArray)，如下所示：|1786259|class+ListArray<T>+:+List<T[]>+{+}|code-block|syntax|javascript|1786260|你也可以用构造函数来声明它：|1786261|class+ListArray<T>+:+List<T[]>
{
++++public+ListArray()+:+base()+{+}
++++public+ListArray(int+capacity)+:+base(capacity)+{+}
}|1786262|例如，您从文件中读取了一些键/值对，并且只想按读取顺序存储它们，以便稍后按索引获取它们：|1786263|ListArray<string>+settingsRead+=+new+ListArray<string>();
using+(var+sr+=+new+StreamReader(myFile))
{
++++string+line;
++++while+((line+=+sr.ReadLine())+!=+null)
++++{
++++++++string[]+keyValueStrings+=+line.Split(separator);
++++++++for+(int+i+=+0;+i+<+keyValueStrings.Length;+i%2B%2B)
++++++++++++keyValueStrings[i]+=+keyValueStrings[i].Trim();
++++++++settingsRead.Add(keyValueStrings);
++++}
}
//+Later+you+get+your+key/value+strings+simply+by+index
string[]+myKeyValueStrings+=+settingsRead[index];|1786264|正如您可能已经注意到的，您的ListArray中不一定只有键/值对。项数组可以是任意长度的，就像锯齿数组一样。|1786265|entityMap|0|LINK|mutability|MUTABLE|url|https://visualstudio.uservoice.com/forums/121579-visual-studio-2015/suggestions/16494583-generic-ordereddictionary|1|https://github.com/mattmc3/dotmore/blob/master/dotmore/Collections/Generic/OrderedDictionary.cs^0|E|9|0|14|14|1|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]]|C|$]]|$1|D|3|E|5|6|7|1B|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1C|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1D|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|1E|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|1F|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1G|8|@]|9|@]|C|$I|J]]|$1|S|3|T|5|6|7|1H|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]]]

Visual Studio's <a href="https://visualstudio.uservoice.com/forums/121579-visual-studio-2015/suggestions/16494583-generic-ordereddictionary" rel="nofollow noreferrer">UserVoice</a> gives a link to <a href="https://github.com/mattmc3/dotmore/blob/master/dotmore/Collections/Generic/OrderedDictionary.cs" rel="nofollow noreferrer">generic OrderedDictionary implementation</a> by dotmore.

But if you only need to get key/value pairs by index and don't need to get values by keys, you may use one simple trick. Declare some generic class (I called it ListArray) as follows:

<pre><code>class ListArray&lt;T&gt; : List&lt;T[]&gt; { }
</code></pre>

You may also declare it with constructors:

<pre><code>class ListArray&lt;T&gt; : List&lt;T[]&gt;
{
 public ListArray() : base() { }
 public ListArray(int capacity) : base(capacity) { }
}
</code></pre>

For example, you read some key/value pairs from a file and just want to store them in the order they were read so to get them later by index:

<pre><code>ListArray&lt;string&gt; settingsRead = new ListArray&lt;string&gt;();
using (var sr = new StreamReader(myFile))
{
 string line;
 while ((line = sr.ReadLine()) != null)
 {
 string[] keyValueStrings = line.Split(separator);
 for (int i = 0; i &lt; keyValueStrings.Length; i++)
 keyValueStrings[i] = keyValueStrings[i].Trim();
 settingsRead.Add(keyValueStrings);
 }
}
// Later you get your key/value strings simply by index
string[] myKeyValueStrings = settingsRead[index];
</code></pre>

As you may have noticed, you can have not necessarily just pairs of key/value in your ListArray. The item arrays may be of any length, like in jagged array.

I'm using a <code>Dictionary&lt;string, int&gt;</code> where the <code>int</code> is a count of the key.

Now, I need to access the last-inserted Key inside the Dictionary, but I do not know the name of it. The obvious attempt:

<pre><code>int LastCount = mydict[mydict.keys[mydict.keys.Count]];
</code></pre>

does not work, because <code>Dictionary.Keys</code> does not implement a []-indexer.

I just wonder if there is any similar class? I thought about using a Stack, but that only stores a string. I could now create my own struct and then use a <code>Stack&lt;MyStruct&gt;</code>, but I wonder if there is another alternative, essentially a Dictionary that implements an []-indexer on the Keys?

Accessing a Dictionary.Keys Key through a numeric index

Visual Studio

我使用的是一个Dictionary<string, int>，其中int是密钥的计数。现在，我需要访问字典中最后插入的键，但我不知道它的名称。显而易见的尝试是：int LastCount = mydict[mydict.keys[mydict.keys.Count]];不起作用，因为Dictionary.Keys不实现...

问通过数字索引访问Dictionary.Keys键
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过数字索引访问Dictionary.Keys键EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过数字索引访问Dictionary.Keys键
EN