(精华)2020年6月27日 C#类库 一致性HASH帮助类

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

namespace Core.Util
{
    /// 

    /// 一致性HASH,解决传统HASH的扩容难的问题
    /// 注:常用与分布式缓存与分表
    /// 
    /// 泛型
    public class ConsistentHash<T>
    {
        SortedDictionary<int, T> circle { get; set; } = new SortedDictionary<int, T>();//虚拟的圆环，对2的32方取模
        int _replicate = 100;    //虚拟节点数 count
        int[] ayKeys = null;    //缓存节点hash

        /// 

        /// 初始化可迭代的节点数
        /// 
        /// 节点
        public void Init(IEnumerable<T> nodes)
        {
            Init(nodes, _replicate);
        }
        /// 

        /// 初始化可迭代的节点数，默认不缓存
        /// 
        /// 节点
        /// 
        public void Init(IEnumerable<T> nodes, int replicate)
        {
            _replicate = replicate;

            foreach (T node in nodes)
            {
                this.Add(node, false);
            }
            ayKeys = circle.Keys.ToArray();
        }
        /// 

        /// 添加节点，缓存
        /// 
        /// 
        public void Add(T node)
        {
            Add(node, true);
        }
        /// 

        /// 添加虚拟的圆环的节点
        /// 
        /// 节点
        /// 是否缓存node的hash
        private void Add(T node, bool updateKeyArray)
        {
            for (int i = 0; i < _replicate; i++)
            {
                int hash = BetterHash(node.GetHashCode().ToString() + i);
                circle[hash] = node;
            }

            if (updateKeyArray)
            {
                ayKeys = circle.Keys.ToArray();
            }
        }
        /// 

        /// 删除真实机器节点，更新缓存
        /// 
        /// 
        public void Remove(T node)
        {
            for (int i = 0; i < _replicate; i++)
            {
                int hash = BetterHash(node.GetHashCode().ToString() + i);
                if (!circle.Remove(hash))
                {
                    throw new Exception("can not remove a node that not added");
                }
            }
            ayKeys = circle.Keys.ToArray();
        }

        /// 

        /// 判断是否存在key对应的hash，有则返回没有返回最近一个节点
        /// 
        /// 
        /// 
        private T GetNode_slow(String key)
        {
            int hash = BetterHash(key);
            if (circle.ContainsKey(hash))
            {
                return circle[hash];
            }
            // 沿环的顺时针找到一个节点
            int first = circle.Keys.FirstOrDefault(h => h >= hash);
            if (first == new int())
            {
                first = ayKeys[0];
            }
            T node = circle[first];
            return node;
        }

        int First_ge(int[] ay, int val)
        {
            int begin = 0;
            int end = ay.Length - 1;

            if (ay[end] < val || ay[0] > val)
            {
                return 0;
            }

            int mid = begin;
            while (end - begin > 1)
            {
                mid = (end + begin) / 2;
                if (ay[mid] >= val)
                {
                    end = mid;
                }
                else
                {
                    begin = mid;
                }
            }

            if (ay[begin] > val || ay[end] < val)
            {
                throw new Exception("should not happen");
            }

            return end;
        }

        public T GetNode(String key)
        {

            int hash = BetterHash(key);

            int first = First_ge(ayKeys, hash);

            return circle[ayKeys[first]];
        }

        /// 

        /// MurMurHash2算法,性能高,碰撞率低
        /// 
        /// 计算hash的字符串
        /// hash值
        public static int BetterHash(String key)
        {
            uint hash = MurmurHash2.Hash(Encoding.ASCII.GetBytes(key));
            return (int)hash;
        }
    }
}

MurMurHash2算法

using System;
using System.Runtime.InteropServices;

namespace Core.Util
{
    public class MurmurHash2
    {
        public static UInt32 Hash(Byte[] data)
        {
            return Hash(data, 0xc58f1a7b);
        }
        const UInt32 m = 0x5bd1e995;
        const Int32 r = 24;

        [StructLayout(LayoutKind.Explicit)]
        struct BytetoUInt32Converter
        {
            [FieldOffset(0)]
            public Byte[] Bytes;

            [FieldOffset(0)]
            public UInt32[] UInts;
        }

        public static UInt32 Hash(Byte[] data, UInt32 seed)
        {
            Int32 length = data.Length;
            if (length == 0)
                return 0;
            UInt32 h = seed ^ (UInt32)length;
            Int32 currentIndex = 0;
            // array will be length of Bytes but contains Uints
            // therefore the currentIndex will jump with +1 while length will jump with +4
            UInt32[] hackArray = new BytetoUInt32Converter { Bytes = data }.UInts;
            while (length >= 4)
            {
                UInt32 k = hackArray[currentIndex++];
                k *= m;
                k ^= k >> r;
                k *= m;

                h *= m;
                h ^= k;
                length -= 4;
            }
            currentIndex *= 4; // fix the length
            switch (length)
            {
                case 3:
                    h ^= (UInt16)(data[currentIndex++] | data[currentIndex++] << 8);
                    h ^= (UInt32)data[currentIndex] << 16;
                    h *= m;
                    break;
                case 2:
                    h ^= (UInt16)(data[currentIndex++] | data[currentIndex] << 8);
                    h *= m;
                    break;
                case 1:
                    h ^= data[currentIndex];
                    h *= m;
                    break;
                default:
                    break;
            }

            // Do a few final mixes of the hash to ensure the last few
            // bytes are well-incorporated.

            h ^= h >> 13;
            h *= m;
            h ^= h >> 15;

            return h;
        }

    }
}