blocks|key|1858642|text|字典或任何其他形式的哈希表都没有排序。因此，您正在尝试做的是毫无意义的:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1858643|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A dictionary or any other form of hashtable has no ordering. So what you are trying to do is pointless :)

blocks|key|1858724|text|这将是一个Dictionary<int,+SomeObject>+myDictionary，你可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1858725|foreach(SomeObject+_object+in+myDictionary.Values.Reverse())
{
}|code-block|syntax|javascript|1858726|entityMap^0|5|14|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

That would be a <code>Dictionary&lt;int, SomeObject&gt; myDictionary</code>, and you would do it by:

<pre><code>foreach(SomeObject _object in myDictionary.Values.Reverse())
{
}
</code></pre>

blocks|key|2072691|text|如果顺序是最重要的，你可以创建一个Stack并创建一个简单的结构来存储你的int对象对。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2072692|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If the ordering is most important, you could you a Stack and create a simple struct to store your int, Object pair.

blocks|key|1859170|text|我同意@leppie，但我认为你应该得到这个问题的总体答案。这可能是因为你的意思是这个问题是一般的，但意外地选择了一个糟糕的数据结构。字典中的值的顺序应该被认为是特定于实现的；根据文档，它总是与键的顺序相同，但这种顺序也是未指定的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859171|无论如何，没有一种简单的方法可以让foreach反向工作。使用类的枚举器是语法上的糖，并且枚举器只能在一个方向上移动。从技术上讲，答案可能是“反转集合，然后枚举”，但我认为在这种情况下，您只能使用“反向”for循环：|offset|length|style|CODE|1859172|for+(int+i+=+myCollection.Length+-+1;+i+>=+0;+i--)
{
++++//+do+something
}|code-block|syntax|javascript|1859173|entityMap^0|0|H|7|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I agree with @leppie, but think you deserve an answer to the question in general. It could be that you meant for the question to be in general, but accidentally picked a bad data structure. The order of the values in a dictionary should be considered implementation-specific; according to the documentation it is always the same order as the keys, but this order is unspecified as well.

Anyway, there's not a straightforward way to make <code>foreach</code> work in reverse. It's syntactic sugar to using the class's enumerator, and enumerators can only travel in one direction. Technically the answer could be "reverse the collection, then enumerate", but I think this is a case where you'll just have to use a "backwards" for loop:

<pre><code>for (int i = myCollection.Length - 1; i >= 0; i--)
{
 // do something
}</code></pre>

blocks|key|1859281|text|如果您需要字典类型的集合，但又需要保持插入顺序，则可以查看KeyedCollection+here|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1859282|它是字典和列表的合并。这样，您就可以通过键或插入索引访问集合中的元素。|1859283|唯一的问题是，如果要存储在集合中的元素必须有一个int键。如果您可以将其更改为字符串或其他类型(Guid+Mabye)。因为集合1将搜索关键字1而不是索引1。|1859284|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms132438.aspx|1^0|19|4|0|0|0|1S|1|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|H|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|O]]]]

If you want a dictionary type collection but you need to maintain the insertion order you can look into the KeyedCollection
<a href="http://msdn.microsoft.com/en-us/library/ms132438.aspx" rel="nofollow noreferrer">here</a>

It is a merger between a dictionary and a list. That way you can access elements in the collection via the key or the insertion index.

The only gotcha is if your element being stored in the collection has to have an int key. If you could change that to a string or another type (Guid Mabye). Since collection<a href="http://msdn.microsoft.com/en-us/library/ms132438.aspx" rel="nofollow noreferrer">1</a> will be searching for the key of 1 rather than the index of 1.

blocks|key|2073237|text|标准的for循环将是最好的。您不必担心反转集合的处理开销。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2073238|entityMap^0|3|3|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|$]]

A standard <code>for</code> loop would be best. You don't have to worry about the processing overhead of reversing the collection.

blocks|key|1859440|text|我会用SortedList而不是字典。您仍然可以通过键来访问它，但也可以通过索引来访问它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859441|SortedList+sCol+=+new+SortedList();

sCol.Add("bee",+"Some+extended+string+matching+bee");
sCol.Add("ay",+"value+matching+ay");
sCol.Add("cee",+"Just+a+standard+cee");

//+Go+through+it+backwards.
for+(int+i+=+sCol.Count+-+1;+i+>=0+;+i--)
++++Console.WriteLine("sCol["+%2B+i.ToString()+%2B+"]+=+"+%2B+sCol.GetByIndex(i));

//+Reference+By+Key
foreach+(string+i+in+sCol.Keys)
++++Console.WriteLine("sCol["+%2B+i+%2B+"]+=+"+%2B+sCol[i]);

//+Enumerate+all+values
foreach+(string+i+in+sCol.Values)
++++Console.WriteLine(i);|code-block|syntax|javascript|1859442|值得注意的是，排序列表仅存储按键排序的键/值对。|1859443|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'd use a SortedList instead of a dictionary. You can still access it by Key, but you can access it by index as well.

<pre><code>SortedList sCol = new SortedList();

sCol.Add("bee", "Some extended string matching bee");
sCol.Add("ay", "value matching ay");
sCol.Add("cee", "Just a standard cee");

// Go through it backwards.
for (int i = sCol.Count - 1; i &gt;=0 ; i--)
 Console.WriteLine("sCol[" + i.ToString() + "] = " + sCol.GetByIndex(i));

// Reference By Key
foreach (string i in sCol.Keys)
 Console.WriteLine("sCol[" + i + "] = " + sCol[i]);

// Enumerate all values
foreach (string i in sCol.Values)
 Console.WriteLine(i);
</code></pre>

It's worth noting that a sorted list stores key/value pairs sorted by key only.

blocks|key|1859549|text|实际上，在C#+2.0中，您可以创建自己的迭代器来反向遍历容器。然后，您可以在foreach语句中使用该迭代器。但是您的迭代器首先必须有一种导航容器的方法。如果它是一个简单的数组，它可以像这样倒退：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859550|static+IEnumerable<T>+CreateReverseIterator<T>(IList<T>+list)
{
++++int+count+=+list.Count;
++++for+(int+i+=+count+-+1;+i+>=+0;+--i)
++++{
++++++++yield+return+list[i];
++++}
}|code-block|syntax|javascript|1859551|但是当然你不能用字典来做到这一点，因为它没有实现IList或者提供索引器。说字典没有顺序是不正确的:它当然有顺序。如果你知道它是什么，这个命令甚至会很有用。|1859552|对于您的问题的解决方案:我建议将元素复制到一个数组中，并使用上面的方法反向遍历它。如下所示：|1859553|static+void+Main(string[]+args)
{
++++Dictionary<int,+string>+dict+=+new+Dictionary<int,+string>();

++++dict[1]+=+"value1";
++++dict[2]+=+"value2";
++++dict[3]+=+"value3";

++++foreach+(KeyValuePair<int,+string>+item+in+dict)
++++{
++++++++Console.WriteLine("Key+:+{0},+Value:+{1}",+new+object[]+{+item.Key,+item.Value+});
++++}

++++string[]+values+=+new+string[dict.Values.Count];
++++dict.Values.CopyTo(values,+0);

++++foreach+(string+value+in+CreateReverseIterator(values))
++++{
++++++++Console.WriteLine("Value:+{0}",+value);
++++}

}|1859554|将值复制到数组中似乎不是一个好主意，但根据值的类型不同，这并不是很糟糕。你可能只是在复制引用！|1859555|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|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Actually, in C# 2.0 you can create your own iterator that traverses a container in reverse. Then, you can use that iterator in your foreach statement. But your iterator would have to have a way of navigating the container in the first place. If it's a simple array, it could go backwards like this:

<pre><code>static IEnumerable&lt;T&gt; CreateReverseIterator&lt;T&gt;(IList&lt;T&gt; list)
{
 int count = list.Count;
 for (int i = count - 1; i &gt;= 0; --i)
 {
 yield return list[i];
 }
}
</code></pre>

But of course you can't do that with a Dictionary as it doesn't implement IList or provides an indexer. Saying that a Dictionary does not have order is not true: of course it has order. That order can even be useful if you know what it is.

For a solution to your problem: I'd say copy the elements to an array, and use the above method to traverse it in reverse. Like this:

<pre><code>static void Main(string[] args)
{
 Dictionary&lt;int, string&gt; dict = new Dictionary&lt;int, string&gt;();

 dict[1] = "value1";
 dict[2] = "value2";
 dict[3] = "value3";

 foreach (KeyValuePair&lt;int, string&gt; item in dict)
 {
 Console.WriteLine("Key : {0}, Value: {1}", new object[] { item.Key, item.Value });
 }

 string[] values = new string[dict.Values.Count];
 dict.Values.CopyTo(values, 0);

 foreach (string value in CreateReverseIterator(values))
 {
 Console.WriteLine("Value: {0}", value);
 }

}
</code></pre>

Copying your values to an array may seem like a bad idea, but depending on the type of value it's not really that bad. You might just be copying references!

blocks|key|1859588|text|您可以通过LinqBridge在.NET+2.0中使用LINQ to Objects+Enumerable.Reverse()函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1859589|entityMap|0|LINK|mutability|MUTABLE|url|http://www.albahari.com/nutshell/linqbridge.html|1|http://en.wikipedia.org/wiki/Language_Integrated_Query#LINQ_to_Objects^0|5|A|0|R|F|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 use the <a href="http://en.wikipedia.org/wiki/Language_Integrated_Query#LINQ_to_Objects" rel="nofollow noreferrer">LINQ&nbsp;to&nbsp;Objects</a> Enumerable.Reverse() function in .NET 2.0 using <a href="http://www.albahari.com/nutshell/linqbridge.html" rel="nofollow noreferrer">LinqBridge</a>.

blocks|key|2073552|text|字面上的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073553|Dictionary<int,+SomeObject>++myDictionary+=+new+Dictionary<int,+SomeObject>();

foreach+(var+pair+in+myDictionary.OrderByDescending(i+=>+i.Key))
{
++++//Observe+pair.Key
++++//Do+stuff+to+pair.Value
}|code-block|syntax|javascript|2073554|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|$]]

Literal answer:

<pre><code>Dictionary&lt;int, SomeObject&gt; myDictionary = new Dictionary&lt;int, SomeObject&gt;();

foreach (var pair in myDictionary.OrderByDescending(i =&gt; i.Key))
{
 //Observe pair.Key
 //Do stuff to pair.Value
}
</code></pre>

blocks|key|2073617|text|如果你没有.NET+3.5，因此没有反向扩展方法，你可以实现自己的方法。我猜它可能会生成一个中间列表(在必要时)并反向迭代它，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073618|public+static+IEnumerable<T>+Reverse<T>(IEnumerable<T>+items)
{
++++IList<T>+list+=+items+as+IList<T>;
++++if+(list+==+null)+list+=+new+List<T>(items);
++++for+(int+i+=+list.Count+-+1;+i+>=+0;+i--+)
++++{
++++++++yield+return+list[i];
++++}
}|code-block|syntax|javascript|2073619|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 you don't have .NET 3.5 and therefore the Reverse extension method you can implement your own. I'd guess it probably generates an intermediate list (when necessary) and iterates it in reverse, something like the following:

<pre><code>public static IEnumerable&lt;T&gt; Reverse&lt;T&gt;(IEnumerable&lt;T&gt; items)
{
 IList&lt;T&gt; list = items as IList&lt;T&gt;;
 if (list == null) list = new List&lt;T&gt;(items);
 for (int i = list.Count - 1; i &gt;= 0; i-- )
 {
 yield return list[i];
 }
}
</code></pre>

blocks|key|2072860|text|如果您使用的是.NET+3.5，则可以在IEnumerables上使用.Reverse()扩展方法。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2072861|foeach+(SomeObject+o+in+myDictionary.Values.Reverse())
{
+++++//+Do+stuff+to+object
}|code-block|syntax|javascript|2072862|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 you have .NET 3.5 you can use the .Reverse() extension method on IEnumerables. For example:

<pre><code>foeach (SomeObject o in myDictionary.Values.Reverse())
{
 // Do stuff to object
}
</code></pre>

blocks|key|1859754|text|foreach+(Sample+in+Samples)

try+the+following:

Int32+nEndingSample+=+Samples.Count+-+1;

for+(i+=+nEndingSample;+i+>=+0;+i--)
{
+++++x+=+Samples[i].x;
+++++y+=+Samples[i].y;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1859755|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>foreach (Sample in Samples)

try the following:

Int32 nEndingSample = Samples.Count - 1;

for (i = nEndingSample; i &gt;= 0; i--)
{
 x = Samples[i].x;
 y = Samples[i].y;
}
</code></pre>

Lets say I have a Dictionary object:

<pre><code>Dictionary myDictionary&lt;int, SomeObject&gt; = new Dictionary&lt;string, SomeObject&gt;();
</code></pre>

Now I want to iterate through the dictionary in reverse order. I can't use a simple for loop because I don't know the keys of the dictionary. A foreach is easy:

<pre><code>foreach (SomeObject object in myDictionary.Values)
{
 // Do stuff to object
}
</code></pre>

But how can I perform this in reverse?

In C# .NET 2.0, what's an easy way to do a foreach in reverse?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

假设我有一个Dictionary对象：Dictionary myDictionary<int, SomeObject> = new Dictionary<string, SomeObject>();现在，我想以相反的顺序遍历字典。我不能使用简单的for循环，因为我不知道字典的关键字。foreach很简单：foreach...

问在C# .NET 2.0中，有什么简单的方法可以反向执行foreach？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C# .NET 2.0中，有什么简单的方法可以反向执行foreach？EN