Distinct源码分析

以前比较两个List数据，筛选出所需要的数据时候，一直套两层for循环来执行。用到去重(Distinct)的时候，这两个需求其实都是一样的，都是需要比较两个集合，查看了下它的源码，里面确实有值得借鉴的地方。

先附上源码一直我调试的代码,大部分地方加上了注释

class Program
    {
        static void Main(string[] args)
        {
            //初始化集合
            List<Point> points = new List<Point>()
            {
                new Point() {X=1,Y=2},
                new Point() {X=7,Y=2},
                new Point() {X=2,Y=2},
                new Point() {X=2,Y=3},
                new Point() {X=3,Y=2},
                new Point() {X=4,Y=2},
                new Point() {X=5,Y=2},
                new Point() {X=6,Y=3},
                new Point() {X=2,Y=3}
            };
            var distinctPoints = DistinctIterator(points, new PointCompare()).ToList();
            Console.Read();
        }

        //调用Distinct 方法 内部调的这个方法  抽取出来了
        static IEnumerable<TSource> DistinctIterator<TSource>(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
        {
            Set<TSource> set = new Set<TSource>(comparer);
            foreach (TSource element in source)
                if (set.Add(element))
                    //若返回true则添加到集合中
                    yield return element;
        }
    }

    struct Point
    {
        public int X { get; set; }

        public int Y { get; set; }
    }

    class PointCompare : IEqualityComparer<Point>
    {


        public bool Equals(Point x, Point y)
        {
            return x.X == y.X && x.Y == y.Y;
            //return false;
        }

        public int GetHashCode(Point obj)
        {
            //  return 1;
            return obj.X.GetHashCode() ^ obj.Y.GetHashCode();
        }
    }

    internal class Set<TElement>
    {
        int[] buckets;
        Slot[] slots;
        int count;
        int freeList;
        IEqualityComparer<TElement> comparer;

        public Set() : this(null) { }

        //初始化
        public Set(IEqualityComparer<TElement> comparer)
        {
            //若comparer为null则string、int...基元类型
            if (comparer == null) comparer = EqualityComparer<TElement>.Default;
            this.comparer = comparer;
            //大小为7
            buckets = new int[7];
            //大小为7
            slots = new Slot[7];
            freeList = -1;
        }

        // If value is not in set, add it and return true; otherwise return false
        public bool Add(TElement value)
        {
            //若Find返回true则代表已重复，则不会添加到集合中
            return !Find(value, true);
        }

        // Check whether value is in set 
        //没用到
        public bool Contains(TElement value)
        {
            return Find(value, false);
        }

        // If value is in set, remove it and return true; otherwise return false 
        //没用到
        public bool Remove(TElement value)
        {
            int hashCode = InternalGetHashCode(value);
            int bucket = hashCode % buckets.Length;
            int last = -1;
            for (int i = buckets[bucket] - 1; i >= 0; last = i, i = slots[i].next)
            {
                if (slots[i].hashCode == hashCode && comparer.Equals(slots[i].value, value))
                {
                    if (last < 0)
                    {
                        buckets[bucket] = slots[i].next + 1;
                    }
                    else
                    {
                        slots[last].next = slots[i].next;
                    }
                    slots[i].hashCode = -1;
                    slots[i].value = default(TElement);
                    slots[i].next = freeList;
                    freeList = i;
                    return true;
                }
            }
            return false;
        }

        bool Find(TElement value, bool add)
        {
            //调用comparer的GetHashCode
            int hashCode = InternalGetHashCode(value);
            //根据hash值取余运算  查找相同结果的数据 比较hash值以及调用IEqualityComparer.Equals方法，若相同  则代表存在相同数据
            for (int i = buckets[hashCode % buckets.Length] - 1; i >= 0; i = slots[i].next)
            {
                if (slots[i].hashCode == hashCode && comparer.Equals(slots[i].value, value)) return true;
            }
            if (add)
            {
                int index;
                //没用到。。。
                if (freeList >= 0)
                {
                    index = freeList;
                    freeList = slots[index].next;
                }
                else
                {
                    //当循环数量大于slots.Length值(初始7)时则会扩充slots，buckets的数量，以及重置对应hash值的取余
                    if (count == slots.Length) Resize();
                    index = count;
                    count++;
                }
                //hash取余
                int bucket = hashCode % buckets.Length;
                //设置hash值
                slots[index].hashCode = hashCode;
                //指向当前的元素
                slots[index].value = value;
                //指向相同hash取余的上一个元素索引*  有了这个才能够在判断是否重复的地方减少比较量
                slots[index].next = buckets[bucket] - 1;
                //指向最近的相同元素
                buckets[bucket] = index + 1;
            }
            return false;
        }

        void Resize()
        {
            //不理解要+1  保证奇数?
            int newSize = checked(count * 2 + 1);
            int[] newBuckets = new int[newSize];
            Slot[] newSlots = new Slot[newSize];
            Array.Copy(slots, 0, newSlots, 0, count);
            for (int i = 0; i < count; i++)
            {
                int bucket = newSlots[i].hashCode % newSize;
                newSlots[i].next = newBuckets[bucket] - 1;
                newBuckets[bucket] = i + 1;
            }
            buckets = newBuckets;
            slots = newSlots;
        }

        internal int InternalGetHashCode(TElement value)
        {
            //[....] DevDivBugs 171937. work around comparer implementations that throw when passed null
            return (value == null) ? 0 : comparer.GetHashCode(value) & 0x7FFFFFFF;
        }

        internal struct Slot
        {
            //value的hash值
            internal int hashCode;
            //元素
            internal TElement value;
            //指向下一个元素索引
            internal int next;
        }
    }

着重说说它去重的思路，代码可以拷出来调试一步一步走，会对下面的更能理解

他用到了hash环的思路，初始大小是7，图随便画的，丑陋还请海涵

1.第一个Point元素hash值取余为3
solts[0]=当前元素 next=-1 hash=3
buckets[3]=1 指向第一个元素索引+1    其实也是当前的count数

2.第二个Point元素hash值取余为5
solts[1]=当前元素 next=-1 hash=5
buckets[5]=2 指向第二个元素索引+1
....
3.假设第三个Point元素hash值为10，取余为3
会对相同取余结果值的元素比较，目前来说也就是第一步的Point元素 比较对应的hash值以及调用Equals方法 返回false(上面两部也会比较，但因为没有元素所以未强调)
则solts[2]=当前元素 next=0(这样子在第128行进行比较的时候就产生了一个类似链表性质) hash=10
buckets[3]=3 指向第三个元素索引+1

4.假设第四个Point元素跟第一个元素相同 也就是hash也为3 

同样也会执行第128行  根据 buckets[3] 得到对应的第一个元素为3-1=2  取solts[2] 得到第三步的元素，进行比较， 很显然两个元素不相同，根据对应的next也就是0得到第一个元素solts[0]进行比较  返回true也就是存在相同元素，则去掉当前重复项。

很显然你会发现第二个元素没有进行比较,这样子就会较少数据的比较次数。

当元素越来越多的时候 144行的时候就会执行他的Resize方法，会将大小*2+1（为啥要+1?），对应的hash取余结果重写来计算

你会发现Distinct里面对GetHashCode依赖特别大，我发现很多人实现IEqualityComparer<T>接口时不会关注他的GetHashCode方法(只是返回了一个特定的int值)，而只是实现了里面的Equals方法，通过上面的解释你会发现这样子其实比我们用两次for循环开销很大，所以强烈建议重写他的GetHashCode方法。

强调一点，当两个元素的相同时，那他的hashcode肯定也是相同的

希望这样的思路能在大家的coding中有所帮助