equals（）方法？(equals() method?)

 更新通过不需要任何特定的哈希来简化[1] 
 
 更新泛化为通用SimpleShuffle扩展方法 
 
        public static IEnumerable<T> SimpleShuffle<T>(this IEnumerable<T> sequence)
        {
            var rand = new Random();
            return sequence.Select(i => new {i, k=rand.Next()})
                .OrderBy(p => p.k)
                .Select(p => p.i);
        }
 
 
 我虽然除了downvoting（大喊？对不起:)）Anx的答案我认为这将是更好的也显示我的代码将看起来像： 
 
using System;
using System.Linq;
using System.Collections.Generic;

namespace NS
{
    static class Program
    {
        public static IEnumerable<T> SimpleShuffle<T>(this IEnumerable<T> sequence)
        {
            var rand = new Random();
            return sequence.Select(i => new {i, k=rand.Next()}).OrderBy(p => p.k).Select(p => p.i);
        }

        public static void Main(string[] args)
        {
            var pts = from x in Enumerable.Range(0, 24)
                from y in Enumerable.Range(0, 11)
                select new { x, y };

            foreach (var pt in pts.SimpleShuffle())
                Console.WriteLine("{0},{1}", pt.x, pt.y);
        }
    }
}
 
 我完全解决了我以前的问题：如何通过意识到我们不需要散列来产生一个好的散列，除非： 
 
 
 
 一个。 源包含（逻辑）重复项 
 
 
 湾 我们需要那些具有相同的排序顺序 
 
 
 C。 我们希望每次都有相同的“随机”排序顺序（确定性哈希） 
 
 
 一个。 和b。 在这种情况下是错误的，并且c。 甚至会成为一个问题（取决于OP所要求的）。 所以现在，没有任何附加条件，不再担心表现（即使是非理性的担忧）， 
 
 祝你好运！ 
 
 [1]顺便说一句，这使整个事情更加灵活，因为我不再需要coords被表示为一个byte []; 你现在可以洗牌你想要的任何结构。 

Update Simplified by not requiring any specific hashing [1]
 
Update Generalzed into generic SimpleShuffle extension method
 
        public static IEnumerable<T> SimpleShuffle<T>(this IEnumerable<T> sequence)
        {
            var rand = new Random();
            return sequence.Select(i => new {i, k=rand.Next()})
                .OrderBy(p => p.k)
                .Select(p => p.i);
        }
 
 
I though in addition to downvoting (shouting? sorry :)) Anx's answer I thought it'd be nicer to also show what my code would look like:
 
using System;
using System.Linq;
using System.Collections.Generic;

namespace NS
{
    static class Program
    {
        public static IEnumerable<T> SimpleShuffle<T>(this IEnumerable<T> sequence)
        {
            var rand = new Random();
            return sequence.Select(i => new {i, k=rand.Next()}).OrderBy(p => p.k).Select(p => p.i);
        }

        public static void Main(string[] args)
        {
            var pts = from x in Enumerable.Range(0, 24)
                from y in Enumerable.Range(0, 11)
                select new { x, y };

            foreach (var pt in pts.SimpleShuffle())
                Console.WriteLine("{0},{1}", pt.x, pt.y);
        }
    }
}
 
I totally fixed my earlier problem of how to generate a good hash by realizing that we don't need a hash unless:
 
 
 
a. the source contains (logical) duplicates
 
 
b. and we need those to have equivalent sort order
 
 
c. and we want to have the same 'random' sort order (deterministic hashing) each time round
 
 
a. and b. are false in this case and c. was even going to be a problem (depending on what the OP was requiring). So now, without any strings attached, no more worries about performance (even the irrational worries), 
 
Good luck!
 
[1] Incidentally this makes the whole thing more flexible because I no longer require the coords to be expressed a byte[]; you can now shuffle any structure you want.