redis 專題 （三）set和zset操作

set和zset主要是對集合的操作，這個在數據處理的場景中，我覺得挺實用的。包括對數據的去重、交集、並集等處理，都很方便。

  using (RedisClient client = new RedisClient("127.0.0.1", 6379))
            {
                //刪除當前數據庫中的所有Key  默認刪除的是db0
                client.FlushDb();
                //刪除所有數據庫中的key 
                client.FlushAll();

                string key = "keyiwang";

                #region 添加鍵值，自帶去重功能
                //同一個key，可以添加多個值；同一個key，同一個值，不會重復寫入，可用於投票、點贊之類，達到同一個ip或同一個賬號不能重復操作
                //client.AddItemToSet(key, "張三豐");
                //client.AddItemToSet(key, "張三豐");
                //client.AddItemToSet(key, "火工頭陀");

                //foreach (var item in client.GetAllItemsFromSet(key))
                //{
                //    Console.WriteLine(item);
                //}

                #endregion

                #region 隨機獲取key集合中的一個值，獲取當前setid所有值
                //client.AddRangeToSet(key, new List<string>() { "張三", "張三", "李四", "王五" });
                ////當前setid中值的數量
                //Console.WriteLine("數量："+client.GetSetCount(key));
                ////隨機獲取key中的一個值
                //Console.WriteLine("隨機值："+client.GetRandomItemFromSet(key));
                ////獲取當前setid中所有的值
                //var lists = client.GetAllItemsFromSet(key);
                //foreach(var item in lists)
                //{
                //    Console.WriteLine(item);

                //}

                #endregion


                #region 並集，把兩個集合合並起來，去重

                //client.AddRangeToSet("key1", new List<string>() { "001", "002", "003", "004" });
                //client.AddRangeToSet("key2", new List<string>() { "001", "003", "005", "006" });

                //var unionlist = client.GetUnionFromSets("key1", "key2"); //合並
                //Console.WriteLine("返回並集結果");
                //foreach(var item in unionlist)
                //{
                //    Console.WriteLine(item);
                //}

                ////把 key1和key2 並集結果存放到newkey集合中
                //client.StoreUnionFromSets("newkey", "key1", "key2");

                //Console.WriteLine("返回並集結果的新集合數據");
                //foreach(var item in client.GetAllItemsFromSet("newkey"))
                //{
                //    Console.WriteLine(item);
                //}

                #endregion

                #region 交集，獲取兩個集合中共同的元素

                //client.AddRangeToSet("key1", new List<string>() { "001", "002", "003", "004" });
                //client.AddRangeToSet("key2", new List<string>() { "001", "003", "005", "006" });
                //client.AddRangeToSet("key3", new List<string>() { "000", "007", "008", "009" });
                //var intersectList = client.GetIntersectFromSets("key1", "key2");
                //Console.WriteLine("返回交集結果的新集合數據");
                //foreach (var item in intersectList)
                //{
                //    Console.WriteLine(item);
                //}
                ////把 key1和key2 並集結果存放到newkey集合中
                //client.StoreIntersectFromSets("newkey", "key1", "key2");

                //Console.WriteLine("返回交集結果的新集合數據");
                //foreach (var item in client.GetAllItemsFromSet("newkey"))
                //{
                //    Console.WriteLine(item);
                //}

                // 把key1集合中的數據與key2集合中的數據對比，fromkey集合中不存在keys集合中，則把這些不存在的數據放入newkey集合中
                //client.StoreDifferencesFromSet("key3", "key1", "key2");
                //foreach (var item in client.GetAllItemsFromSet("key3"))
                //{
                //    Console.WriteLine(item);
                //}


                #endregion


                #region ZSet的操作
                //zset就是set的一個分支版本，它增加了一個分值，比如權重。能夠按照分值進行排序。

                //  client.AddRangeToSortedSet(key, new List<string>() { "aa", "bb" }, 100);


                client.AddItemToSortedSet(key, "關羽", 2);
                client.AddItemToSortedSet(key, "劉備", 1);
                client.AddItemToSortedSet(key, "張飛", 3);
                ////獲取當前value的結果,排序，升序
                //foreach(var item in client.GetAllItemsFromSortedSet(key))
                //{
                //    Console.WriteLine(item);
                //}
                //獲取分值2到3范圍內的數據，查詢出來就是關羽和張飛滿足
                //var list= client.GetRangeFromSortedSetByHighestScore(key, 2, 3);


               var list = client.GetRangeFromSortedSet(key, 0, 1); //按下標索引 0,先排序，默認是升序，升序完后取第N-M個數（含NM），類似分頁
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }

                #endregion

                //更多zset用法，參考https://www.cnblogs.com/knowledgesea/p/5032101.html




            }

下面是摘自別人的方法匯總：

把 RedisBase.Core 替換成我們自己的redis客戶端對象即可。

.Net操作Redis數據類型Set

public class DoRedisSet:DoRedisBase
    {
        #region 添加
        /// <summary>
        /// key集合中添加value值
        /// </summary>
        public void Add(string key, string value)
        {
            RedisBase.Core.AddItemToSet(key,value);
        }
        /// <summary>
        /// key集合中添加list集合
        /// </summary>
        public void Add(string key, List<string> list)
        {
            RedisBase.Core.AddRangeToSet(key, list);
        }
        #endregion
        #region 獲取
        /// <summary>
        /// 隨機獲取key集合中的一個值
        /// </summary>
        public string GetRandomItemFromSet(string key)
        {
           return RedisBase.Core.GetRandomItemFromSet(key);
        }
        /// <summary>
        /// 獲取key集合值的數量
        /// </summary>
        public long GetCount(string key)
        {
            return RedisBase.Core.GetSetCount(key);
        }
        /// <summary>
        /// 獲取所有key集合的值
        /// </summary>
        public HashSet<string> GetAllItemsFromSet(string key)
        {
            return RedisBase.Core.GetAllItemsFromSet(key);
        }
        #endregion
        #region 刪除
        /// <summary>
        /// 隨機刪除key集合中的一個值
        /// </summary>
        public string PopItemFromSet(string key)
        {
            return RedisBase.Core.PopItemFromSet(key);
        }
        /// <summary>
        /// 刪除key集合中的value
        /// </summary>
        public void RemoveItemFromSet(string key, string value)
        {
            RedisBase.Core.RemoveItemFromSet(key,value);
        }
        #endregion
        #region 其它
        /// <summary>
        /// 從fromkey集合中移除值為value的值，並把value添加到tokey集合中
        /// </summary>
        public void MoveBetweenSets(string fromkey,string tokey,string value)
        {
             RedisBase.Core.MoveBetweenSets(fromkey,tokey,value);
        }
        /// <summary>
        /// 返回keys多個集合中的並集，返還hashset
        /// </summary>
        public HashSet<string> GetUnionFromSets(string[] keys)
        {
           return RedisBase.Core.GetUnionFromSets(keys);
        }
        /// <summary>
        /// keys多個集合中的並集，放入newkey集合中
        /// </summary>
        public void StoreUnionFromSets(string newkey, string[] keys)
        {
             RedisBase.Core.StoreUnionFromSets(newkey,keys);
        }
        /// <summary>
        /// 把fromkey集合中的數據與keys集合中的數據對比，fromkey集合中不存在keys集合中，則把這些不存在的數據放入newkey集合中
        /// </summary>
        public void StoreDifferencesFromSet(string newkey, string fromkey, string[] keys)
        {
            RedisBase.Core.StoreDifferencesFromSet(newkey,fromkey,keys);
        }
        #endregion
    }

.Net操作Redis數據類型有序集合Zset 

zset和set的區別在於 zset給我們按照分數進行了排序。

public class DoRedisZSet : DoRedisBase
    {
        #region 添加
        /// <summary>
        /// 添加key/value，默認分數是從1.多*10的9次方以此遞增的,自帶自增效果
        /// </summary>
        public bool AddItemToSortedSet(string key, string value)
        {
           return RedisBase.Core.AddItemToSortedSet(key, value);
        }
        /// <summary>
        /// 添加key/value,並設置value的分數
        /// </summary>
        public bool AddItemToSortedSet(string key, string value, double score)
        {
            return RedisBase.Core.AddItemToSortedSet(key, value, score);
        }
        /// <summary>
        /// 為key添加values集合，values集合中每個value的分數設置為score
        /// </summary>
        public bool AddRangeToSortedSet(string key,List<string> values,double score)
        {
            return RedisBase.Core.AddRangeToSortedSet(key, values, score);
        }
        /// <summary>
        /// 為key添加values集合，values集合中每個value的分數設置為score
        /// </summary>
        public bool AddRangeToSortedSet(string key, List<string> values, long score)
        {
            return RedisBase.Core.AddRangeToSortedSet(key, values, score);
        }
        #endregion
        #region 獲取
        /// <summary>
        /// 獲取key的所有集合
        /// </summary>
        public List<string> GetAllItemsFromSortedSet(string key)
        {
            return RedisBase.Core.GetAllItemsFromSortedSet(key);
        }
        /// <summary>
        /// 獲取key的所有集合，倒敘輸出
        /// </summary>
        public List<string> GetAllItemsFromSortedSetDesc(string key)
        {
            return RedisBase.Core.GetAllItemsFromSortedSetDesc(key);
        }
        /// <summary>
        /// 獲取可以的說有集合，帶分數
        /// </summary>
        public IDictionary<string, double> GetAllWithScoresFromSortedSet(string key)
        {
            return RedisBase.Core.GetAllWithScoresFromSortedSet(key);
        }
        /// <summary>
        /// 獲取key為value的下標值
        /// </summary>
        public long GetItemIndexInSortedSet(string key, string value)
        {
            return RedisBase.Core.GetItemIndexInSortedSet(key, value);
        }
        /// <summary>
        /// 倒敘排列獲取key為value的下標值
        /// </summary>
        public long GetItemIndexInSortedSetDesc(string key, string value)
        {
            return RedisBase.Core.GetItemIndexInSortedSetDesc(key, value);
        }
        /// <summary>
        /// 獲取key為value的分數
        /// </summary>
        public double GetItemScoreInSortedSet(string key,string value)
        {
            return RedisBase.Core.GetItemScoreInSortedSet(key,value);
        }
        /// <summary>
        /// 獲取key所有集合的數據總數
        /// </summary>
        public long GetSortedSetCount(string key)
        {
            return RedisBase.Core.GetSortedSetCount(key);
        }
        /// <summary>
        /// key集合數據從分數為fromscore到分數為toscore的數據總數
        /// </summary>
        public long GetSortedSetCount(string key,double fromScore,double toScore)
        {
            return RedisBase.Core.GetSortedSetCount(key,fromScore,toScore);
        }
        /// <summary>
        /// 獲取key集合從高分到低分排序數據，分數從fromscore到分數為toscore的數據
        /// </summary>
        public List<string> GetRangeFromSortedSetByHighestScore(string key, double fromscore, double toscore)
        {
            return RedisBase.Core.GetRangeFromSortedSetByHighestScore(key, fromscore, toscore);
        }
        /// <summary>
        /// 獲取key集合從低分到高分排序數據，分數從fromscore到分數為toscore的數據
        /// </summary>
        public List<string> GetRangeFromSortedSetByLowestScore(string key, double fromscore, double toscore)
        {
            return RedisBase.Core.GetRangeFromSortedSetByLowestScore(key, fromscore, toscore);
        }
        /// <summary>
        /// 獲取key集合從高分到低分排序數據，分數從fromscore到分數為toscore的數據，帶分數
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string key, double fromscore, double toscore)
        {
            return RedisBase.Core.GetRangeWithScoresFromSortedSetByHighestScore(key, fromscore, toscore);
        }
        /// <summary>
        ///  獲取key集合從低分到高分排序數據，分數從fromscore到分數為toscore的數據，帶分數
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string key, double fromscore, double toscore)
        {
            return RedisBase.Core.GetRangeWithScoresFromSortedSetByLowestScore(key, fromscore, toscore);
        }
        /// <summary>
        ///  獲取key集合數據，下標從fromRank到分數為toRank的數據
        /// </summary>
        public List<string> GetRangeFromSortedSet(string key, int fromRank, int toRank)
        {
            return RedisBase.Core.GetRangeFromSortedSet(key, fromRank, toRank);
        }
        /// <summary>
        /// 獲取key集合倒敘排列數據，下標從fromRank到分數為toRank的數據
        /// </summary>
        public List<string> GetRangeFromSortedSetDesc(string key, int fromRank, int toRank)
        {
            return RedisBase.Core.GetRangeFromSortedSetDesc(key, fromRank, toRank);
        }
        /// <summary>
        /// 獲取key集合數據，下標從fromRank到分數為toRank的數據，帶分數
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSet(string key, int fromRank, int toRank)
        {
            return RedisBase.Core.GetRangeWithScoresFromSortedSet(key, fromRank, toRank);
        }
        /// <summary>
        ///  獲取key集合倒敘排列數據，下標從fromRank到分數為toRank的數據，帶分數
        /// </summary>
        public IDictionary<string, double> GetRangeWithScoresFromSortedSetDesc(string key, int fromRank, int toRank)
        {
            return RedisBase.Core.GetRangeWithScoresFromSortedSetDesc(key, fromRank, toRank);
        }
        #endregion
        #region 刪除
        /// <summary>
        /// 刪除key為value的數據
        /// </summary>
        public bool RemoveItemFromSortedSet(string key,string value)
        {
            return RedisBase.Core.RemoveItemFromSortedSet(key, value);
        }
        /// <summary>
        /// 刪除下標從minRank到maxRank的key集合數據
        /// </summary>
        public long RemoveRangeFromSortedSet(string key,int minRank,int maxRank)
        {
            return RedisBase.Core.RemoveRangeFromSortedSet(key,minRank,maxRank);
        }
        /// <summary>
        /// 刪除分數從fromscore到toscore的key集合數據
        /// </summary>
        public long RemoveRangeFromSortedSetByScore(string key, double fromscore, double toscore)
        {
            return RedisBase.Core.RemoveRangeFromSortedSetByScore(key, fromscore, toscore);
        }
        /// <summary>
        /// 刪除key集合中分數最大的數據
        /// </summary>
        public string PopItemWithHighestScoreFromSortedSet(string key)
        {
            return RedisBase.Core.PopItemWithHighestScoreFromSortedSet(key);
        }
        /// <summary>
        /// 刪除key集合中分數最小的數據
        /// </summary>
        public string PopItemWithLowestScoreFromSortedSet(string key)
        {
            return RedisBase.Core.PopItemWithLowestScoreFromSortedSet(key);
        }
        #endregion
        #region 其它
        /// <summary>
        /// 判斷key集合中是否存在value數據
        /// </summary>
        public bool SortedSetContainsItem(string key, string value)
        {
            return RedisBase.Core.SortedSetContainsItem(key,value);
        }
        /// <summary>
        /// 為key集合值為value的數據，分數加scoreby，返回相加后的分數
        /// </summary>
        public double IncrementItemInSortedSet(string key,string value,double scoreBy)
        {
            return RedisBase.Core.IncrementItemInSortedSet(key,value,scoreBy);
        }
        /// <summary>
        /// 獲取keys多個集合的交集，並把交集添加的newkey集合中，返回交集數據的總數
        /// </summary>
        public long StoreIntersectFromSortedSets(string newkey, string[] keys)
        {
            return RedisBase.Core.StoreIntersectFromSortedSets(newkey,keys);
        }
        /// <summary>
        /// 獲取keys多個集合的並集，並把並集數據添加到newkey集合中，返回並集數據的總數
        /// </summary>
        public long StoreUnionFromSortedSets(string newkey, string[] keys)
        {
            return RedisBase.Core.StoreUnionFromSortedSets(newkey, keys);
        }
        #endregion
    }