redishelp

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace LXYD.WebGame.Util.MiscHelpers
{
public static class CacheHelper
{
//默认缓存过期时间单位秒
public static void Configure()
{
int maxWritePoolSize = FeatureHelpers.FeatureHelpers.MaxWritePoolSize;
int maxReadPoolSize = FeatureHelpers.FeatureHelpers.MaxReadPoolSize;
string redisConfig = SystemConfig.RedisConfig;
if (redisConfig.Contains("#"))
{
var arr = redisConfig.Split(’#’);
if (arr.Length == 2)
{
string[] readWriteHosts = arr[0].Split(’|’, ‘,’);
string[] readOnlyHosts = arr[1].Split(’|’, ‘,’);
RedisClientManager.InitRedis(readWriteHosts, readOnlyHosts, maxWritePoolSize, maxReadPoolSize);
}
}
else
{
string[] readWriteHosts = redisConfig.Split(’|’, ‘,’);
string[] readOnlyHosts = readWriteHosts;
RedisClientManager.InitRedis(readWriteHosts, readOnlyHosts, maxWritePoolSize, maxReadPoolSize);
}
}

    /// <summary>
    /// redis手动初始化
    /// </summary>
    /// <param name="maxWritePoolSize"></param>
    /// <param name="maxReadPoolSize"></param>
    /// <param name="RedisConfig"></param>
    public static void Configure(int maxWritePoolSize, int maxReadPoolSize, string RedisConfig)
    {
        RedisClientManager.InitRedis(new string[] { RedisConfig }, new string[] { RedisConfig }, maxWritePoolSize, maxReadPoolSize);
    }

    /// <summary>
    /// 清空所有Cache
    /// </summary>
    public static void ClearAll() => RedisClientManager.FlushAll();

    #region Key/Value存储
    /// <summary>
    /// 设置缓存
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">缓存建</param>
    /// <param name="t">缓存值</param>
    /// <param name="hours">过期时间，单位小时,-1：不过期，0：默认过期时间</param>
    /// <returns></returns>
    public static bool Set<T>(string key, T t, int hours = -1)
    {
        bool flag = false;
        if (CacheKeys.HasNeedCompress(key))
        {
            string value = Newtonsoft.Json.JsonConvert.SerializeObject(t);
            string str = GzipString.Compress(value);
            flag = RedisClientManager.Set<string>(key, str, hours);
        }
        else
        {
            flag = RedisClientManager.Set<T>(key, t, hours);
        }
        return flag;
    }

    public static bool Set<T>(string key, T t, TimeSpan timeOut)
    {
        bool flag = false;
        if (CacheKeys.HasNeedCompress(key))
        {
            string value = Newtonsoft.Json.JsonConvert.SerializeObject(t);
            string str = GzipString.Compress(value);
            flag = RedisClientManager.Set<string>(key, str, timeOut);
        }
        else
        {
            flag = RedisClientManager.Set<T>(key, t, timeOut);
        }
        return flag;
    }
    /// <summary>
    /// 写入Redis
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <param name="timeOut"></param>
    /// <returns></returns>
    public static bool Set(string key, string value, TimeSpan? timeOut)
    {
        bool flag = false;
        if (CacheKeys.HasNeedCompress(key))
        {
            string str = GzipString.Compress(value);
            flag = RedisClientManager.Set(key, str, timeOut);
        }
        else
        {
            flag = RedisClientManager.Set(key, value, timeOut);
        }
        return flag;
    }
    /// <summary>
    /// 获取
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public static T Get<T>(string key)
    {
        T t = default(T);
        if (CacheKeys.HasNeedCompress(key))
        {
            string value = RedisClientManager.Get<string>(key);
            string str = GzipString.Decompress(value);
            if (string.IsNullOrWhiteSpace(str))
                return default(T);
            t = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(str);
        }
        else
        {
            t = RedisClientManager.Get<T>(key);
        }
        return t;
    }
    /// <summary>
    /// 获取
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static string Get(string key)
    {
        string value = string.Empty;
        if (CacheKeys.HasNeedCompress(key))
        {
            string data = RedisClientManager.Get<string>(key);
            value = GzipString.Decompress(data);
        }
        else
        {
            value = RedisClientManager.Get(key);
        }
        return value;
    }
    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static bool Remove(string key) => RedisClientManager.Remove(key);

    /// <summary>
    /// 批量删除
    /// </summary>
    /// <param name="keys"></param>
    /// <returns></returns>
    public static void RemoveAll(IEnumerable<string> keys)
    {
        if (keys != null && keys.Any())
            RedisClientManager.RemoveAll(keys);
    }

    /// <summary>
    /// 批量删除
    /// </summary>
    /// <param name="keys"></param>
    public static void RemoveAll(params string[] keys)
    {
        if (keys != null && keys.Any())
            RedisClientManager.RemoveAll(keys);
    }

    public static bool Add<T>(string key, T t, int hours = -1)
    {
        bool flag = false;
        if (CacheKeys.HasNeedCompress(key))
        {
            string value = Newtonsoft.Json.JsonConvert.SerializeObject(t);
            string str = GzipString.Compress(value);
            flag = RedisClientManager.Add<string>(key, str, hours);
        }
        else
        {
            flag = RedisClientManager.Add<T>(key, t, hours);
        }
        return flag;
    }
    #endregion

    #region 有序集合操作

    /// <summary>
    /// 获取有序集合中的所有元素KEY.
    /// </summary>
    /// <param name="setId"></param>
    /// <returns></returns>
    public static List<string> GetAllItemsFromSortedSet(string setId)
    {
        return RedisClientManager.GetAllItemsFromSortedSet(setId);
    }

    / <summary>
    / 根据KEY获取值
    / </summary>
    / <param name="setId"></param>
    / <param name="key"></param>
    / <returns></returns>
    //public static double GetItemValueByKey(string setId, string key)
    //{
    //    return RedisClientManager.GetItemVauleByKey(setId, key);
    //}

    /// <summary>
    /// 获取集合数据.(正序)
    /// </summary>
    /// <param name="setId"></param>
    /// <param name="minValue"></param>
    /// <param name="maxValue"></param>
    /// <returns></returns>
    public static IDictionary<string, double> GetRangeWithScoresFromSortedSetByAsc(string setId, int minValue, int maxValue)
    {
        return RedisClientManager.GetRangeWithScoresFromSortedSetByAsc(setId, minValue, maxValue);
    }

    /// <summary>
    /// 获取集合数据。（倒叙）
    /// </summary>
    /// <param name="setId"></param>
    /// <param name="minValue"></param>
    /// <param name="maxValue"></param>
    /// <returns></returns>
    public static IDictionary<string, double> GetRangeWithScoresFromSortedSetByDesc(string setId, int minValue, int maxValue)
    {
        return RedisClientManager.GetRangeWithScoresFromSortedSetByDesc(setId, minValue, maxValue);
    }

    /// <summary>
    /// 将元素加入有序集合
    /// </summary>
    /// <param name="setId"></param>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static bool AddItemToSortedSet(string setId, string key, double value)
    {
        return RedisClientManager.AddItemToSortedSet(setId, key, value);
    }

    /// <summary>
    /// 获取有序集合中的数量
    /// </summary>
    /// <param name="setId"></param>
    /// <returns></returns>
    public static long GetSortedSetCount(string setId)
    {
        return RedisClientManager.GetSortedSetCount(setId);
    }

    /// <summary>
    /// 获取有序集合中的数量(根据值范围)
    /// </summary>
    /// <param name="setId"></param>
    /// <returns></returns>
    public static long GetSortedSetCount(string setId, double minValue, double maxValue)
    {
        return RedisClientManager.GetSortedSetCount(setId, minValue, maxValue);
    }

    /// <summary>
    /// 移除有序集合的元素 (根据值范围)
    /// </summary>
    /// <param name="setId"></param>
    /// <param name="minValue"></param>
    /// <param name="maxValue"></param>
    /// <returns></returns>
    public static long RemoveSortedSetByRange(string setId, double minValue, double maxValue)
    {
        return RedisClientManager.RemoveSortedSetByRange(setId, minValue, maxValue);
    }

    /// <summary>
    /// 移除有序集合的元素.
    /// </summary>
    /// <param name="setId"></param>
    /// <param name="key"></param>
    /// <returns></returns>
    public static bool RemoveItemFromSortedSet(string setId, string key)
    {
        return RedisClientManager.RemoveItemFromSortedSet(setId, key);
    }

    #endregion

    #region 链表操作
    /// <summary>
    /// 根据IEnumerable数据添加链表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="listId"></param>
    /// <param name="values"></param>
    /// <param name="timeout"></param>
    public static void AddList<T>(string listId, IEnumerable<T> values, int hours = -1)
    {
        if (CacheKeys.HasNeedCompress(listId))
        {
            List<string> list = new List<string>();
            foreach (var item in values)
            {
                string value = Newtonsoft.Json.JsonConvert.SerializeObject(item);
                string str = GzipString.Compress(value);
                list.Add(str);
            }
            RedisClientManager.AddList<string>(listId, list, hours);
        }
        else
        {
            RedisClientManager.AddList<T>(listId, values, hours);
        }
    }
    public static long GetListCount(string listId)
    {
        return RedisClientManager.GetListCount(listId);
    }
    /// <summary>
    /// 根据List数据添加链表
    /// </summary>
    /// <param name="listId"></param>
    /// <param name="values"></param>
    /// <param name="hours"></param>
    public static void AddRangeToList(string listId, List<string> values, int hours = -1)
    {
        if (CacheKeys.HasNeedCompress(listId))
        {
            List<string> list = new List<string>();
            foreach (var item in values)
            {
                string str = GzipString.Compress(item);
                list.Add(str);
            }
            RedisClientManager.AddRangeToList(listId, list, hours);
        }
        else
        {
            RedisClientManager.AddRangeToList(listId, values, hours);
        }
    }
    /// <summary>
    /// 添加单个对象到List
    /// </summary>
    /// <param name="listId"></param>
    /// <param name="value"></param>
    /// <param name="hours"></param>
    public static void AddItemToList(string listId, string value, int hours = -1)
    {
        if (CacheKeys.HasNeedCompress(listId))
        {
            string str = GzipString.Compress(value);
            RedisClientManager.AddItemToList(listId, str, hours);
        }
        else
        {
            RedisClientManager.AddItemToList(listId, value, hours);
        }
    }
    /// <summary>
    /// 获取链表集合
    /// </summary>
    /// <param name="listId"></param>
    /// <returns></returns>
    public static List<string> GetAllItemsFromList(string listId)
    {
        return RedisClientManager.GetAllItemsFromList(listId);
    }
    /// <summary>
    /// 获取链表中指定的对象
    /// </summary>
    /// <param name="listId"></param>
    /// <param name="listIndex"></param>
    /// <returns></returns>
    public static string GetItemFromList(string listId, int listIndex)
    {
        return RedisClientManager.GetItemFromList(listId, listIndex);
    }
    /// <summary>
    /// 清除链表
    /// </summary>
    /// <param name="listId"></param>
    public static void RemoveList<T>(string listId)
    {
        RedisClientManager.RemoveList<T>(listId);
    }
    /// <summary>
    /// 添加单个实体到链表中
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="listId"></param>
    /// <param name="item"></param>
    /// <param name="timeout"></param>
    public static void AddEntityToList<T>(string listId, T item, int hours = -1)
    {
        if (CacheKeys.HasNeedCompress(listId))
        {
            string value = Newtonsoft.Json.JsonConvert.SerializeObject(item);
            string str = GzipString.Compress(value);
            RedisClientManager.AddEntityToList<string>(listId, str, hours);
        }
        else
        {
            RedisClientManager.AddEntityToList<T>(listId, item, hours);
        }
    }

    /// <summary>
    /// 获取链表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="listId"></param>
    /// <returns></returns>
    public static IEnumerable<T> GetList<T>(string listId)
    {
        if (CacheKeys.HasNeedCompress(listId))
        {
            List<T> list = new List<T>();
            var values = RedisClientManager.GetList<string>(listId);
            foreach (var item in values)
            {
                string str = GzipString.Decompress(item);
                if (string.IsNullOrWhiteSpace(str))
                    continue;
                var t = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(str);
                list.Add(t);
            }
            return list;
        }
        else
        {
            return RedisClientManager.GetList<T>(listId);
        }
    }
    /// <summary>
    /// 在链表中删除单个实体
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="listId"></param>
    /// <param name="t"></param>
    public static void RemoveEntityFromList<T>(string listId, T t)
    {
        if (CacheKeys.HasNeedCompress(listId))
        {
            string value = Newtonsoft.Json.JsonConvert.SerializeObject(t);
            string str = GzipString.Compress(value);
            RedisClientManager.RemoveEntityFromList(listId, str);
        }
        else
        {
            RedisClientManager.RemoveEntityFromList(listId, t);
        }
    }
    /// <summary>
    /// 删除并返回链表中第一个元素
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="listId"></param>
    public static T RemoveStartFromList<T>(string listId)
    {
        if (CacheKeys.HasNeedCompress(listId))
        {
            var item = RedisClientManager.RemoveStartFromList<string>(listId);
            string str = GzipString.Decompress(item);
            if (string.IsNullOrWhiteSpace(str))
                return default(T);
            return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(str);
        }
        else
        {
            return RedisClientManager.RemoveStartFromList<T>(listId);
        }
    }
    #endregion

    #region <Hash>
    /// <summary>
    /// 判断Hash数据集中是否存在key的数据
    /// </summary>
    public static bool HashContainsEntry(string hashId, string key) => RedisClientManager.HashContainsEntry(hashId, key);
    /// <summary>
    /// 向Hash集合中添加key/value
    /// </summary>
    public static bool SetEntryInHash(string hashId, string key, string value) => RedisClientManager.SetEntryInHash(hashId, key, value);
    /// <summary>
    /// 批量向Hash添加数据
    /// </summary>
    /// <param name="hashId"></param>
    /// <param name="keyValuePairs"></param>
    public static void SetRangeInHash(string hashId, IEnumerable<KeyValuePair<string, string>> keyValuePairs)
    {
        if (keyValuePairs != null && keyValuePairs.Any())
        {
            RedisClientManager.SetRangeInHash(hashId, keyValuePairs);
        }
    }
    /// <summary>
    /// 删除Hash数据集中的key数据
    /// </summary>
    public static bool RemoveEntryFromHash(string hashId, string key) => RedisClientManager.RemoveEntryFromHash(hashId, key);
    /// <summary>
    /// 获取Hash数据集中，key的value数据
    /// </summary>
    public static string GetValueFromHash(string hashId, string key) => RedisClientManager.GetValueFromHash(hashId, key);
    /// <summary>
    /// 获取Hash数据集中的所有value集合
    /// </summary>
    public static List<string> GetHashValues(string hashId) => RedisClientManager.GetHashValues(hashId);
    #endregion

    #region <Set>
    /// <summary>
    /// 添加单个对象到HashSet
    /// </summary>
    /// <param name="setId"></param>
    /// <param name="value"></param>
    /// <param name="hours"></param>
    public static void AddItemToSet(string setId, string value, int hours = -1)
    {
        if (CacheKeys.HasNeedCompress(setId))
        {
            string str = GzipString.Compress(value);
            RedisClientManager.AddItemToSet(setId, str, hours);
        }
        else
        {
            RedisClientManager.AddItemToSet(setId, value, hours);
        }
    }

    /// <summary>
    /// 批量添加集合到HashSet
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="setId"></param>
    /// <param name="values"></param>
    /// <param name="hours"></param>
    public static void AddRangeToSet(string setId, List<string> values, int hours = -1)
    {
        if (CacheKeys.HasNeedCompress(setId))
        {
            List<string> list = new List<string>();
            foreach (var item in values)
            {
                string str = GzipString.Compress(item);
                list.Add(str);
            }
            RedisClientManager.AddRangeToSet(setId, list, hours);
        }
        else
        {
            RedisClientManager.AddRangeToSet(setId, values, hours);
        }
    }

    /// <summary>
    /// 获取HashSet集合
    /// </summary>
    /// <param name="setId"></param>
    /// <returns></returns>
    public static HashSet<string> GetAllItemsFromSet(string setId)
    {
        if (CacheKeys.HasNeedCompress(setId))
        {
            HashSet<string> hashSet = new HashSet<string>();
            var values = RedisClientManager.GetAllItemsFromSet(setId);
            foreach (var item in values)
            {
                string str = GzipString.Decompress(item);
                if (string.IsNullOrWhiteSpace(str))
                    continue;
                hashSet.Add(str);
            }
            return hashSet;
        }
        else
        {
            return RedisClientManager.GetAllItemsFromSet(setId);
        }
    }
    /// <summary>
    /// 在HashSet中删除单个实体
    /// </summary>
    /// <param name="setId"></param>
    /// <param name="item"></param>
    public static void RemoveItemFromSet(string setId, string item) => RedisClientManager.RemoveItemFromSet(setId, item);
    #endregion

    /// <summary>
    /// 入列
    /// </summary>
    /// <param name="key"></param>
    /// <param name="Data"></param>
    public static void WriteRedis(string key, string Data) => RedisClientManager.WriteRedis(key, Data);
    /// <summary>
    /// 出列
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static string ReadRedis(string key) => RedisClientManager.ReadRedis(key);

    #region <批量操作>
    /// <summary>
    /// 批量获取Redis数据
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="keys"></param>
    /// <returns></returns>
    public static IDictionary<string, T> GetAll<T>(IEnumerable<string> keys)
    {
        IDictionary<string, T> result = new Dictionary<string, T>();
        bool flag = false;
        if (keys.Any())
            flag = CacheKeys.HasNeedCompress(keys.First());
        if (flag)
        {
            IDictionary<string, string> values = RedisClientManager.GetAll<string>(keys);
            foreach (var item in values)
            {
                if (!string.IsNullOrWhiteSpace(item.Value))
                {
                    string str = GzipString.Decompress(item.Value);
                    var value = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(str);
                    result.Add(item.Key, value);
                }
            }
        }
        else
        {
            return RedisClientManager.GetAll<T>(keys);
        }
        return result;
    }
    /// <summary>
    /// 批量获取Redis数据
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="keys"></param>
    /// <returns></returns>
    public static IDictionary<string, string> GetAll(IEnumerable<string> keys)
    {
        IDictionary<string, string> result = new Dictionary<string, string>();
        IDictionary<string, string> redisData = RedisClientManager.GetAll(keys);
        foreach (var item in redisData)
        {
            if (!string.IsNullOrWhiteSpace(item.Value))
            {
                if (CacheKeys.HasNeedCompress(item.Key))
                {
                    string str = GzipString.Decompress(item.Value);
                    result[item.Key] = str;
                }
                else
                {
                    result[item.Key] = item.Value;
                }
            }
        }
        return result;
    }
    /// <summary>
    /// 批量存入
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="values"></param>
    /// <param name="expiresIn"></param>
    public static void SetAll<T>(IDictionary<string, T> values, TimeSpan? expiresIn = null)
    {
        if (values != null && values.Any())
        {
            bool flag = CacheKeys.HasNeedCompress(values.Keys.First());
            if (flag)
            {
                IDictionary<string, string> result = new Dictionary<string, string>();
                foreach (var item in values)
                {
                    if (item.Value != null)
                    {
                        string value = Newtonsoft.Json.JsonConvert.SerializeObject(item.Value);
                        string str = GzipString.Compress(value);
                        result.Add(item.Key, str);
                    }
                }
                RedisClientManager.SetAll(result, expiresIn);
            }
            else
            {
                RedisClientManager.SetAll(values, expiresIn);
            }
        }
    }
    /// <summary>
    /// 批量存入
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="values"></param>
    /// <param name="expiresIn"></param>
    public static void SetAll(IDictionary<string, string> values, TimeSpan? expiresIn = null)
    {
        if (values != null && values.Any())
        {
            IDictionary<string, string> result = new Dictionary<string, string>();
            foreach (var item in values)
            {
                if (item.Value != null)
                {
                    if (CacheKeys.HasNeedCompress(item.Key))
                    {
                        string str = GzipString.Compress(item.Value);
                        result.Add(item.Key, str);
                    }
                    else
                    {
                        result.Add(item.Key, item.Value);
                    }
                }
            }
            RedisClientManager.SetAll(result, expiresIn);
        }
    }
    #endregion
    /// <summary>
    /// 查找匹配的队列id
    /// </summary>
    /// <param name="pattern"></param>
    /// <returns></returns>
    public static List<string> SearchKeys(string pattern) => RedisClientManager.SearchKeys(pattern);
    /// <summary>
    /// 获取所有队列key
    /// </summary>
    /// <returns></returns>
    public static List<string> GetAllKeys() => RedisClientManager.GetAllKeys();
    /// <summary>
    /// 是否包含某个key
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static bool ContainsKey(string key) => RedisClientManager.ContainsKey(key);
    /// <summary>        
    /// 判断key是否存在，如果不存在则插入，返回true；如果存在，则返回false；
    /// 利用AcquireLock全局锁处理并发。
    /// </summary>
    /// <typeparam name="T">设置的值的类型</typeparam>
    /// <param name="lockKey">全局锁的名称</param>
    /// <param name="lockTimeOut">获取锁的超时时间</param>
    /// <param name="key">设置的值得key</param>
    /// <param name="t">设置的值</param>
    /// <param name="cacheTimeOut">设置的值，过期时间</param>
    /// <returns></returns>
    public static bool MySetNX<T>(string lockKey, TimeSpan lockTimeOut, string key, T t, TimeSpan cacheTimeOut)
    {
        return RedisClientManager.MySetNX<T>(lockKey, lockTimeOut, key, t, cacheTimeOut);
    }
}

/// <summary>
/// 缓存过去时间
/// </summary>
public static class CacheTimeOut
{
    /// <summary>
    /// 三秒
    /// </summary>
    public static TimeSpan ThreeSecond = new TimeSpan(0, 0, 3);
    /// <summary>
    /// 五秒
    /// </summary>
    public static TimeSpan FiveSecond = new TimeSpan(0, 0, 5);
    /// <summary>
    /// 十秒
    /// </summary>
    public static TimeSpan TenSecond = new TimeSpan(0, 0, 10);
    /// <summary>
    /// 二十秒
    /// </summary>
    public static TimeSpan TwentySecond = new TimeSpan(0, 0, 20);
    /// <summary>
    /// 三十秒
    /// </summary>
    public static TimeSpan ThirtySecond = new TimeSpan(0, 0, 30);
    /// <summary>
    /// 一分钟
    /// </summary>
    public static TimeSpan OneMinute = new TimeSpan(0, 1, 0);
    /// <summary>
    /// 两分钟
    /// </summary>
    public static TimeSpan TwoMinute = new TimeSpan(0, 2, 0);
    /// <summary>
    /// 三分钟
    /// </summary>
    public static TimeSpan ThreeMinute = new TimeSpan(0, 3, 0);
    /// <summary>
    /// 五分钟
    /// </summary>
    public static TimeSpan FiveMinute = new TimeSpan(0, 5, 0);
    /// <summary>
    /// 十分钟
    /// </summary>
    public static TimeSpan TenMinute = new TimeSpan(0, 10, 0);
    /// <summary>
    /// 二十分钟
    /// </summary>
    public static TimeSpan TwentyMinute = new TimeSpan(0, 20, 0);
    / <summary>
    / 三十分钟
    / </summary>
    //public static TimeSpan ThirtyMinute = new TimeSpan(0, 30, 0);
    / <summary>
    / 一小时
    / </summary>
    //public static TimeSpan OneHour = new TimeSpan(1, 0, 0);
    / <summary>
    / 两小时
    / </summary>
    //public static TimeSpan TwoHour = new TimeSpan(2, 0, 0);
    / <summary>
    / 三小时
    / </summary>
    //public static TimeSpan ThreeHour = new TimeSpan(3, 0, 0);
    / <summary>
    / 五小时
    / </summary>
    //public static TimeSpan FiveHour = new TimeSpan(5, 0, 0);
    / <summary>
    / 十小时
    / </summary>
    //public static TimeSpan TenHour = new TimeSpan(10, 0, 0);
    / <summary>
    / 二十小时
    / </summary>
    //public static TimeSpan TwentyHour = new TimeSpan(20, 0, 0);
}

}