你能在 C# 中无序枚举一个集合吗？

你可以倒过来做：

for (int i=col.count-1; i>0; i--){ 
      DoSomething ( col.item[i]) ;
}

不确定确切的语法，但这就是范式。

至于完全随机的顺序，你可以通过它的索引来访问一个集合元素。为了确保命中每个项目，您需要跟踪已经处理了哪些元素（可能是通过复制集合，然后在访问后删除元素）。

编辑：随机访问的更多详细信息 随机访问的代码可能如下所示：

 collection c = originalCollection;
 while (c.count > 0) {
     int i = randomNumber(seed) mod c.count
     element d = c[i];
     c.remove(d);
     DoSomething(d);
}

我认为没有办法直接这样做，但几乎就是使用通过 yield return 关键字返回新集合的扩展方法。这些可能来自预先存在的库;其他人指出 LINQ 有一种方法，类似的东西也行得通。as goodReverseOrderBy

示例：如果在 上使用 LINQ 扩展方法，该方法用于以相反的顺序提供集合，则执行 将以相反的顺序枚举集合。Reverse()IEnumerable<T>yield returnforeach(var myThing in myCollection.Reverse())

重要提示：是关键。它的意思是“当我枚举这个集合时，然后去取东西。与仅构建一个新的反向集合的替代方案相反，后者效率非常低，并且可能具有副作用。yield return

使用你可以做...System.Linq

// List<...> list;
foreach (var i in list.Reverse())
{
}

对于随机顺序，您必须使用（另一个 Linq 扩展）对其进行随机排序，然后迭代该有序列表。list.OrderBy

var rnd = new Random();
var randomlyOrdered = list.OrderBy(i => rnd.Next());
foreach (var i in randomlyOrdered)
{
}

您可以通过提供自己的比较器来对列表进行排序，并遍历该比较器。

正如其他答案所提到的，Reverse（） 扩展方法将允许您以相反的顺序枚举序列。

下面是一个随机枚举扩展方法：

public static IEnumerable<T> OrderRandomly<T>(this IEnumerable<T> sequence)
{
    Random random = new Random();
    List<T> copy = sequence.ToList();

    while (copy.Count > 0)
    {
        int index = random.Next(copy.Count);
        yield return copy[index];
        copy.RemoveAt(index);
    }
}

您的用法为：

foreach (int n in Enumerable.Range(1, 10).OrderRandomly())
    Console.WriteLine(n);

你想创建一个集合并与之交互吗？

如果是，请尝试以下操作：

Random rand = new Random(Environment.TickCount);

test.Sort((string v1, string v2) => {
                if (v1.Equals(v2))
                {
                    return 0;
                }

                int x = rand.Next();
                int y = rand.Next();

                if (x == y)
                {
                    return 0;
                }
                else if (x > y)
                {
                    return 1;
                }

                return -1; 
            });

for (string item in test)
{
  Console.WriteLn(item);
}
// Note that test is List<string>;

根据我对 C# 语言规范的阅读，foreach 迭代语句取决于正在迭代的结构/类/接口，并在其上定义了 GetEnumerator（） 函数。GetEnumerator（） 返回的对象必须将 MoveNext（） 定义为成员函数。MoveNext（） 被定义为在第一次调用时访问列表中的“第一个”对象，然后在后续调用时访问“下一个”对象，返回 true，直到列表中不存在其他元素，然后返回 false。

Domenic 所指的特性，即收益回报，首次出现在规范的 2.0 版本中，并且似乎对这个目的很有用。对于版本 1.1，唯一的选择是从基础派生一个新的结构/类/接口，并重写 GetEnumerator（） 以返回新的 IEnumerator，其中 MoveNext（） 函数在选择第一个集合元素和任何后续集合元素时将遵循不同的规则。

我自己的建议是使用索引集合，然后使用带有适当索引计算的 for 循环（如果需要，这里可以使用随机数生成器，使用整数数组或其他技术来验证相同的索引值是否未被使用两次），如果你必须在实际实践中这样做。

从 C# 2.0 开始，您可以使用 yield 关键字轻松实现自定义迭代器。您可以在 MSDN 上阅读有关 yield 关键字的详细信息 http://msdn.microsoft.com/en-us/library/9k7k7cf0.aspx

您可以将收益视为从循环内部返回值的能力，但您应该参考上面的链接，以全面了解它们是什么以及它们可以做什么。

我写了一个关于如何实现几个自定义迭代器的简短示例。我已将它们实现为扩展方法 （http://msdn.microsoft.com/en-us/library/bb383977.aspx） 以使代码更加流线型，并且我还使用数组初始值设定项 （http://msdn.microsoft.com/en-us/library/aa664573.aspx） 来设置整数列表的初始值。

扩展方法和数组初始值设定项对于实现自定义迭代器都不是必需的，但它们是 c# 3.0 的不错功能，有助于编写更简洁的代码

这是我的例子。它展示了如何通过仅返回奇数、偶数、反向或完全随机方式返回数字来遍历整数列表。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> ints = 
                new List<int> { 1,2,3,4,5,6,7,8,9,10};

            Console.WriteLine("Iterating over Odd numbers only.");
            foreach (int i in ints.Odd())
            {
                Console.WriteLine(i);
            }

            Console.WriteLine("Iterating over Even numbers only.");
            foreach (int i in ints.Even())
            {
                Console.WriteLine(i);
            }

            Console.WriteLine("Iterating over the list in reversed order.");
            foreach (int i in ints.Reversed())
            {
                Console.WriteLine(i);
            }

            Console.WriteLine("Iterating over the list in random order.");
            foreach (int i in ints.Random())
            {
                Console.WriteLine(i);
            }

            Console.ReadLine();
        }
    }

    public static class ListExtensions
    {
        /// <summary>
        /// Iterates over the list only returns even numbers
        /// </summary>
        /// <param name="list"></param>
        public static IEnumerable<int> Even(this List<int> list)
        {
            foreach (var i in list)
            {
                if (i % 2 == 0)
                 {
                    yield return i;
                }
           }
        }

        /// <summary>
        /// Iterates over the list only returns odd numbers
        /// </summary>
        public static IEnumerable<int> Odd(this List<int> list)
        {
            foreach (var i in list)
            {
                if (i % 2 != 0)
                {
                    yield return i;
                }
            }
        }

        /// <summary>
        /// Iterates over the list in reversed order
        /// </summary>
        public static IEnumerable<int> Reversed(this List<int> list)
        {
            for (int i = list.Count; i >= 0; i--)
            {
                yield return i;
            }
        }

        /// <summary>
        /// Iterates over the list in random order
        /// </summary>
        public static IEnumerable<int> Random(this List<int> list)
        {
            // Initialize a random number generator with a seed.
            System.Random rnd =
                new Random((int)DateTime.Now.Ticks);

            // Create a list to keep track of which indexes we've
            // already returned
            List<int> visited =
                new List<int>();

            // loop until we've returned the value of all indexes
            // in the list
            while (visited.Count < list.Count)
            {
                int index =
                    rnd.Next(0, list.Count);

                // Make sure we've not returned it already
                if (!visited.Contains(index))
                {
                    visited.Add(index);
                    yield return list[index];
                }
            }
        }
    }
}

我实际上很喜欢 LINQ 的 cfeduke 方法，它让我很烦恼，它让我忘记了。添加到我之前的示例中。如果要在 LINQ 的帮助下进行奇数和偶数迭代，可以使用

// Even
foreach (var i in ints.FindAll(number => number % 2 == 0))
{
      Console.WriteLine(i);
}

// Odd
foreach (var i in ints.FindAll(number => number % 2 != 0))
{
      Console.WriteLine(i);
}

使用 C5 泛型集合库中的反向迭代是一项功能，而不是扩展：IList<T>

foreach (var i in list.Reverse())
{
}

同样，您可以使用该方法来获取随机排序：Shuffle()

var listClone = (IList<T>) list.Clone();
listClone.Shuffle();
foreach (var i in listClone)
{
}

使用随机排序
http://www.dailycoding.com/..using_linq.aspx

List<Employee> list = new List<Employee>();

list.Add(new Employee { Id = 1, Name = "Davolio Nancy" });
list.Add(new Employee { Id = 2, Name = "Fuller Andrew" });
list.Add(new Employee { Id = 3, Name = "Leverling Janet" });
list.Add(new Employee { Id = 4, Name = "Peacock Margaret" });
list.Add(new Employee { Id = 5, Name = "Buchanan Steven" });
list.Add(new Employee { Id = 6, Name = "Suyama Michael" });
list.Add(new Employee { Id = 7, Name = "King Robert" });
list.Add(new Employee { Id = 8, Name = "Callahan Laura" });
list.Add(new Employee { Id = 9, Name = "Dodsworth Anne" });

list = list.OrderBy(emp => Guid.NewGuid()).ToList();