using Microsoft.Extensions.Options;
using ServiceStack;
using ServiceStack.Redis;
using ServiceStack.Redis.Pipeline;
using ServiceStack.Text;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using Yi.Framework.Common.IOCOptions;

namespace Yi.Framework.Core
{
	public class CacheClientDB : IDisposable
	{
		private readonly RedisConnOptions _RedisOptions;

		#region TestRedisCrack
		//static CacheClientDB()
		//{
		//	try
		//	{
		//		Parallel.For(0, 10000, (i) =>
		//		{
		//			using (RedisClient client = new RedisClient("192.168.3.254"))
		//			{
		//				client.Set("name" + i, i);
		//				client.Incr("name" + i);
		//				Console.WriteLine(i);
		//			}

		//		});
		//		Console.WriteLine("ok");

		//		Console.WriteLine("Hello World!");
		//	}
		//	catch (Exception ex)
		//	{
		//		Console.WriteLine(ex.Message);
		//	}
		//}
		#endregion
		public CacheClientDB(IOptionsMonitor<RedisConnOptions> redisConnOptions)
		{
			this._RedisOptions = redisConnOptions.CurrentValue;
			client = new RedisClient(_RedisOptions.Host, _RedisOptions.Prot, _RedisOptions.Password, _RedisOptions.DB);
		}
		// 管道模式 三种模式
		public IRedisClient GetClient()
		{
			return client;
		}
		private IRedisClient client;

		public void Dispose()
		{

			this.TryCatchException(delegate
			{
				this.client.Dispose();
			}, string.Empty);
		}
		// 为了以后全链路做准备
		private void TryCatchException(Action action, string key)
		{
			try
			{
				action();
			}
			catch (Exception e)
			{

				Console.WriteLine(e.Message);
			}
		}

		private T TryCatch<T>(Func<T> action, string key)
		{
			Stopwatch sw = Stopwatch.StartNew();
			//Exception ex = null;
			//bool isError = false;
			T result;
			try
			{
				result = action();
			}
			catch (Exception exinfo)
			{
				object p=null;
				result =(T)p;
				//isError = true;
				Console.WriteLine(exinfo);

			}
			finally
			{

				sw.Stop();

			}
			
			return result;
		}

		private void TryCatch(Action action, string key)
		{

			Stopwatch sw = Stopwatch.StartNew();
			//bool isError = false;
			//Exception ex = null;
			try
			{
				action();
			}
			catch (Exception exinfo)
			{

				//isError = true;
				Console.WriteLine(exinfo);
			}
			finally
			{
				sw.Stop();

			}
		}
		public bool Add<T>(string key, T value)
		{

			return this.TryCatch<bool>(() => this.client.Add<T>(key, value), key);
		}
		/// <summary>
		///  简单模式  事务模式
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="key"></param>
		/// <param name="value"></param>
		/// <param name="expiresAt"></param>
		/// <returns></returns>
		public bool Add<T>(string key, T value, DateTime expiresAt)
		{

			return this.TryCatch<bool>(() => this.client.Add<T>(key, value, expiresAt), key);
		}

		public bool Add<T>(string key, T value, TimeSpan expiresIn)
		{
			return this.TryCatch<bool>(() => this.client.Add<T>(key, value, expiresIn), key);
		}

		public long Decrement(string key, uint amount)
		{
			return this.TryCatch<long>(() => this.client.Decrement(key, amount), key);
		}

		public void FlushAll()
		{
			this.TryCatch(delegate
			{
				this.client.FlushAll();
			}, string.Empty);
		}

		public T Get<T>(string key)
		{
			return this.TryCatch<T>(() => this.client.Get<T>(key), key);
		}

		public IDictionary<string, T> GetAll<T>(IEnumerable<string> keys)
		{
			return this.TryCatch<IDictionary<string, T>>(() => this.client.GetAll<T>(keys), keys.FirstOrDefault<string>());
		}

		public long Increment(string key, uint amount)
		{
			return this.TryCatch<long>(() => this.client.Increment(key, amount), key);
		}

		public bool Remove(string key)
		{
			return this.TryCatch<bool>(() => this.client.Remove(key), key);
		}

		public void RemoveAll(IEnumerable<string> keys)
		{
			this.TryCatch(delegate
			{
				this.client.RemoveAll(keys);
			}, keys.FirstOrDefault<string>());
		}

		public bool Replace<T>(string key, T value)
		{
			return this.TryCatch<bool>(() => this.client.Replace<T>(key, value), key);
		}

		public bool Replace<T>(string key, T value, DateTime expiresAt)
		{
			return this.TryCatch<bool>(() => this.client.Replace<T>(key, value, expiresAt), key);
		}

		public bool Replace<T>(string key, T value, TimeSpan expiresIn)
		{
			return this.TryCatch<bool>(() => this.client.Replace<T>(key, value, expiresIn), key);
		}

		public bool Set<T>(string key, T value)
		{
			return this.TryCatch<bool>(() => this.client.Set<T>(key, value), key);
		}

		public bool Set<T>(string key, T value, DateTime expiresAt)
		{
			return this.TryCatch<bool>(() => this.client.Set<T>(key, value, expiresAt), key);
		}

		public bool Set<T>(string key, T value, TimeSpan expiresIn)
		{
			return this.TryCatch<bool>(() => this.client.Set<T>(key, value, expiresIn), key);
		}

		public void SetAll<T>(IDictionary<string, T> values)
		{
			this.TryCatch(delegate
			{
				this.client.SetAll<T>(values);
			}, values.Keys.FirstOrDefault<string>());
		}


		public void Delete<T>(T entity) where T : class, new()
		{
			this.TryCatch(delegate
			{
				this.client.Delete<T>(entity);
			}, string.Empty);
		}

		public void DeleteAll<TEntity>() where TEntity : class, new()
		{
			this.TryCatch(delegate
			{
				this.client.DeleteAll<TEntity>();
			}, string.Empty);
		}

		public void DeleteById<T>(object id) where T : class, new()
		{
			this.TryCatch(delegate
			{
				this.client.DeleteById<T>(id);
			}, string.Empty);
		}

		public void DeleteByIds<T>(ICollection ids) where T : class, new()
		{
			this.TryCatch(delegate
			{
				this.client.DeleteById<T>(ids);
			}, string.Empty);
		}

		public T GetById<T>(object id) where T : class, new()
		{
			return this.TryCatch<T>(() => this.client.GetById<T>(id), string.Empty);
		}

		public IList<T> GetByIds<T>(ICollection ids) where T : class, new()
		{
			return this.TryCatch<IList<T>>(() => this.client.GetByIds<T>(ids), string.Empty);
		}

		public T Store<T>(T entity) where T : class, new()
		{
			return this.TryCatch<T>(() => this.client.Store<T>(entity), string.Empty);
		}

		public void StoreAll<TEntity>(IEnumerable<TEntity> entities) where TEntity : class, new()
		{
			this.TryCatch(delegate
			{
				this.client.StoreAll<TEntity>(entities);
			}, string.Empty);
		}

		public void AddItemToList(string listId, string value)
		{
			this.TryCatch(delegate
			{
				this.client.AddItemToList(listId, value);
			}, listId);
		}

		public void AddItemToSet(string setId, string item)
		{
			this.TryCatch(delegate
			{
				this.client.AddItemToSet(setId, item);
			}, setId);
		}

		public bool AddItemToSortedSet(string setId, string value)
		{
			return this.TryCatch<bool>(() => this.client.AddItemToSortedSet(setId, value), setId);
		}

		public bool AddItemToSortedSet(string setId, string value, double score)
		{
			return this.TryCatch<bool>(() => this.client.AddItemToSortedSet(setId, value, score), setId);
		}

		public void AddRangeToList(string listId, List<string> values)
		{
			this.TryCatch(delegate
			{
				this.client.AddRangeToList(listId, values);
			}, listId);
		}

		public void AddRangeToSet(string setId, List<string> items)
		{
			this.TryCatch(delegate
			{
				this.client.AddRangeToSet(setId, items);
			}, setId);
		}

		public bool AddRangeToSortedSet(string setId, List<string> values, double score)
		{
			return this.TryCatch<bool>(() => this.client.AddRangeToSortedSet(setId, values, score), setId);
		}

		public bool AddRangeToSortedSet(string setId, List<string> values, long score)
		{
			return this.TryCatch<bool>(() => this.client.AddRangeToSortedSet(setId, values, score), setId);
		}

		public long AppendToValue(string key, string value)
		{
			return this.TryCatch<long>(() => this.client.AppendToValue(key, value), key);
		}

		public string BlockingDequeueItemFromList(string listId, TimeSpan? timeOut)
		{
			return this.TryCatch<string>(() => this.client.BlockingDequeueItemFromList(listId, timeOut), listId);
		}

		public KeyValuePair<string, string> BlockingDequeueItemFromLists(string[] listIds, TimeSpan? timeOut)
		{
			return this.TryCatch<KeyValuePair<string, string>>(delegate
			{
				ItemRef item = this.client.BlockingDequeueItemFromLists(listIds, timeOut);
				return new KeyValuePair<string, string>(item.Id, item.Item);
			}, listIds[0]);
		}

		public string BlockingPopAndPushItemBetweenLists(string fromListId, string toListId, TimeSpan? timeOut)
		{
			return this.TryCatch<string>(() => this.client.BlockingPopAndPushItemBetweenLists(fromListId, toListId, timeOut), fromListId);
		}

		public string BlockingPopItemFromList(string listId, TimeSpan? timeOut)
		{
			return this.TryCatch<string>(() => this.client.BlockingPopItemFromList(listId, timeOut), listId);
		}

		public KeyValuePair<string, string> BlockingPopItemFromLists(string[] listIds, TimeSpan? timeOut)
		{
			return this.TryCatch<KeyValuePair<string, string>>(delegate
			{
				ItemRef item = this.client.BlockingPopItemFromLists(listIds, timeOut);
				return new KeyValuePair<string, string>(item.Id, item.Item);
			}, listIds[0]);
		}

		public string BlockingRemoveStartFromList(string listId, TimeSpan? timeOut)
		{
			return this.TryCatch<string>(() => this.client.BlockingRemoveStartFromList(listId, timeOut), listId);
		}

		public KeyValuePair<string, string> BlockingRemoveStartFromLists(string[] listIds, TimeSpan? timeOut)
		{
			return this.TryCatch<KeyValuePair<string, string>>(delegate
			{
				ItemRef item = this.client.BlockingRemoveStartFromLists(listIds, timeOut);
				return new KeyValuePair<string, string>(item.Id, item.Item);
			}, listIds[0]);
		}

		public bool ContainsKey(string key)
		{
			return this.TryCatch<bool>(() => this.client.ContainsKey(key), key);
		}

		public long DecrementValue(string key)
		{
			return this.TryCatch<long>(() => this.client.DecrementValue(key), key);
		}

		public long DecrementValueBy(string key, int count)
		{
			return this.TryCatch<long>(() => this.client.DecrementValueBy(key, count), key);
		}

		public string DequeueItemFromList(string listId)
		{
			return this.TryCatch<string>(() => this.client.DequeueItemFromList(listId), listId);
		}

		public void EnqueueItemOnList(string listId, string value)
		{
			this.TryCatch(delegate
			{
				this.client.EnqueueItemOnList(listId, value);
			}, listId);
		}

		public bool ExpireEntryAt(string key, DateTime expireAt)
		{
			return this.TryCatch<bool>(() => this.client.ExpireEntryAt(key, expireAt), key);
		}

		public bool ExpireEntryIn(string key, TimeSpan expireIn)
		{
			return this.TryCatch<bool>(() => this.client.ExpireEntryIn(key, expireIn), key);
		}

		public Dictionary<string, string> GetAllEntriesFromHash(string hashId)
		{
			return this.TryCatch<Dictionary<string, string>>(() => this.client.GetAllEntriesFromHash(hashId), hashId);
		}

		public List<string> GetAllItemsFromList(string listId)
		{
			return this.TryCatch<List<string>>(() => this.client.GetAllItemsFromList(listId), listId);
		}

		public HashSet<string> GetAllItemsFromSet(string setId)
		{
			return this.TryCatch<HashSet<string>>(() => this.client.GetAllItemsFromSet(setId), setId);
		}

		public List<string> GetAllItemsFromSortedSet(string setId)
		{
			return this.TryCatch<List<string>>(() => this.client.GetAllItemsFromSortedSet(setId), setId);
		}

		public List<string> GetAllItemsFromSortedSetDesc(string setId)
		{
			return this.TryCatch<List<string>>(() => this.client.GetAllItemsFromSortedSetDesc(setId), setId);
		}

		public List<string> GetAllKeys()
		{
			return this.TryCatch<List<string>>(() => this.client.GetAllKeys(), string.Empty);
		}

		public IDictionary<string, double> GetAllWithScoresFromSortedSet(string setId)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetAllWithScoresFromSortedSet(setId), setId);
		}

		public string GetAndSetEntry(string key, string value)
		{
			return this.TryCatch<string>(() => this.client.GetAndSetValue(key, value), key);
		}

		public HashSet<string> GetDifferencesFromSet(string fromSetId, params string[] withSetIds)
		{
			return this.TryCatch<HashSet<string>>(() => this.client.GetDifferencesFromSet(fromSetId, withSetIds), fromSetId);
		}

		public T GetFromHash<T>(object id)
		{
			return this.TryCatch<T>(() => this.client.GetFromHash<T>(id), string.Empty);
		}

		public long GetHashCount(string hashId)
		{
			return this.TryCatch<long>(() => this.client.GetHashCount(hashId), hashId);
		}

		public List<string> GetHashKeys(string hashId)
		{
			return this.TryCatch<List<string>>(() => this.client.GetHashKeys(hashId), hashId);
		}

		public List<string> GetHashValues(string hashId)
		{
			return this.TryCatch<List<string>>(() => this.client.GetHashValues(hashId), hashId);
		}

		public HashSet<string> GetIntersectFromSets(params string[] setIds)
		{
			return this.TryCatch<HashSet<string>>(() => this.client.GetIntersectFromSets(setIds), setIds[0]);
		}

		public string GetItemFromList(string listId, int listIndex)
		{
			return this.TryCatch<string>(() => this.client.GetItemFromList(listId, listIndex), listId);
		}

		public long GetItemIndexInSortedSet(string setId, string value)
		{
			return this.TryCatch<long>(() => this.client.GetItemIndexInSortedSet(setId, value), setId);
		}

		public long GetItemIndexInSortedSetDesc(string setId, string value)
		{
			return this.TryCatch<long>(() => this.client.GetItemIndexInSortedSetDesc(setId, value), setId);
		}

		public double GetItemScoreInSortedSet(string setId, string value)
		{
			return this.TryCatch<double>(() => this.client.GetItemScoreInSortedSet(setId, value), setId);
		}

		public long GetListCount(string listId)
		{
			return this.TryCatch<long>(() => this.client.GetListCount(listId), listId);
		}

		public string GetRandomItemFromSet(string setId)
		{
			return this.TryCatch<string>(() => this.client.GetRandomItemFromSet(setId), setId);
		}

		public List<string> GetRangeFromList(string listId, int startingFrom, int endingAt)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromList(listId, startingFrom, endingAt), listId);
		}

		public List<string> GetRangeFromSortedList(string listId, int startingFrom, int endingAt)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedList(listId, startingFrom, endingAt), listId);
		}

		public List<string> GetRangeFromSortedSet(string setId, int fromRank, int toRank)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSet(setId, fromRank, toRank), setId);
		}

		public List<string> GetRangeFromSortedSetByHighestScore(string setId, double fromScore, double toScore)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByHighestScore(setId, fromScore, toScore), setId);
		}

		public List<string> GetRangeFromSortedSetByHighestScore(string setId, long fromScore, long toScore)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByHighestScore(setId, fromScore, toScore), setId);
		}

		public List<string> GetRangeFromSortedSetByHighestScore(string setId, string fromStringScore, string toStringScore)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByHighestScore(setId, fromStringScore, toStringScore), setId);
		}

		public List<string> GetRangeFromSortedSetByHighestScore(string setId, double fromScore, double toScore, int? skip, int? take)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByHighestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public List<string> GetRangeFromSortedSetByHighestScore(string setId, long fromScore, long toScore, int? skip, int? take)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByHighestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public List<string> GetRangeFromSortedSetByHighestScore(string setId, string fromStringScore, string toStringScore, int? skip, int? take)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByHighestScore(setId, fromStringScore, toStringScore, skip, take), setId);
		}

		public List<string> GetRangeFromSortedSetByLowestScore(string setId, double fromScore, double toScore)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByLowestScore(setId, fromScore, toScore), setId);
		}

		public List<string> GetRangeFromSortedSetByLowestScore(string setId, long fromScore, long toScore)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByLowestScore(setId, fromScore, toScore), setId);
		}

		public List<string> GetRangeFromSortedSetByLowestScore(string setId, string fromStringScore, string toStringScore)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByLowestScore(setId, fromStringScore, toStringScore), setId);
		}

		public List<string> GetRangeFromSortedSetByLowestScore(string setId, double fromScore, double toScore, int? skip, int? take)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByLowestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public List<string> GetRangeFromSortedSetByLowestScore(string setId, long fromScore, long toScore, int? skip, int? take)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByLowestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public List<string> GetRangeFromSortedSetByLowestScore(string setId, string fromStringScore, string toStringScore, int? skip, int? take)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetByLowestScore(setId, fromStringScore, toStringScore, skip, take), setId);
		}

		public List<string> GetRangeFromSortedSetDesc(string setId, int fromRank, int toRank)
		{
			return this.TryCatch<List<string>>(() => this.client.GetRangeFromSortedSetDesc(setId, fromRank, toRank), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSet(string setId, int fromRank, int toRank)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSet(setId, fromRank, toRank), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, double fromScore, double toScore)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromScore, toScore), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, long fromScore, long toScore)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromScore, toScore), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, string fromStringScore, string toStringScore)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromStringScore, toStringScore), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, double fromScore, double toScore, int? skip, int? take)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, long fromScore, long toScore, int? skip, int? take)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string setId, string fromStringScore, string toStringScore, int? skip, int? take)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromStringScore, toStringScore, skip, take), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, double fromScore, double toScore)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByHighestScore(setId, fromScore, toScore), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, long fromScore, long toScore)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByLowestScore(setId, fromScore, toScore), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, string fromStringScore, string toStringScore)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByLowestScore(setId, fromStringScore, toStringScore), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, double fromScore, double toScore, int? skip, int? take)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByLowestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, long fromScore, long toScore, int? skip, int? take)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByLowestScore(setId, fromScore, toScore, skip, take), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string setId, string fromStringScore, string toStringScore, int? skip, int? take)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetByLowestScore(setId, fromStringScore, toStringScore, skip, take), setId);
		}

		public IDictionary<string, double> GetRangeWithScoresFromSortedSetDesc(string setId, int fromRank, int toRank)
		{
			return this.TryCatch<IDictionary<string, double>>(() => this.client.GetRangeWithScoresFromSortedSetDesc(setId, fromRank, toRank), setId);
		}

		public long GetSetCount(string setId)
		{
			return this.TryCatch<long>(() => this.client.GetSetCount(setId), setId);
		}

		public List<string> GetSortedEntryValues(string key, int startingFrom, int endingAt)
		{
			return this.TryCatch<List<string>>(() => this.client.GetSortedEntryValues(key, startingFrom, endingAt), key);
		}

		public long GetSortedSetCount(string setId)
		{
			return this.TryCatch<long>(() => this.client.GetSortedSetCount(setId), setId);
		}

		public long GetSortedSetCount(string setId, double fromScore, double toScore)
		{
			return this.TryCatch<long>(() => this.client.GetSortedSetCount(setId, fromScore, toScore), setId);
		}

		public long GetSortedSetCount(string setId, long fromScore, long toScore)
		{
			return this.TryCatch<long>(() => this.client.GetSortedSetCount(setId, fromScore, toScore), setId);
		}

		public long GetSortedSetCount(string setId, string fromStringScore, string toStringScore)
		{
			return this.TryCatch<long>(() => this.client.GetSortedSetCount(setId, fromStringScore, toStringScore), setId);
		}

		public string GetSubstring(string key, int fromIndex, int toIndex)
		{
			return this.TryCatch<string>(delegate
			{
				byte[] bytes = ((RedisClient)this.client).GetRange(key, fromIndex, toIndex);
				if (bytes != null)
				{
					return StringExtensions.FromUtf8Bytes(bytes);
				}
				return null;
			}, key);
		}

		public TimeSpan GetTimeToLive(string key)
		{
			return this.TryCatch<TimeSpan>(delegate
			{
				TimeSpan? t = this.client.GetTimeToLive(key);
				if (!t.HasValue)
				{
					return TimeSpan.Zero;
				}
				return t.Value;
			}, key);
		}

		public HashSet<string> GetUnionFromSets(params string[] setIds)
		{
			return this.TryCatch<HashSet<string>>(() => this.client.GetUnionFromSets(setIds), setIds[0]);
		}

		public string GetValue(string key)
		{
			return this.TryCatch<string>(() => this.client.GetValue(key), key);
		}

		public string GetValueFromHash(string hashId, string key)
		{
			return this.TryCatch<string>(() => this.client.GetValueFromHash(hashId, key), hashId);
		}

		public List<string> GetValues(List<string> keys)
		{
			return this.TryCatch<List<string>>(() => this.client.GetValues(keys), keys[0]);
		}

		public List<T> GetValues<T>(List<string> keys)
		{
			return this.TryCatch<List<T>>(() => this.client.GetValues<T>(keys), keys[0]);
		}

		public List<string> GetValuesFromHash(string hashId, params string[] keys)
		{
			return this.TryCatch<List<string>>(() => this.client.GetValuesFromHash(hashId, keys), hashId);
		}

		public Dictionary<string, T> GetValuesMap<T>(List<string> keys)
		{
			return this.TryCatch<Dictionary<string, T>>(() => this.client.GetValuesMap<T>(keys), keys[0]);
		}

		public Dictionary<string, string> GetValuesMap(List<string> keys)
		{
			return this.TryCatch<Dictionary<string, string>>(() => this.client.GetValuesMap(keys), keys[0]);
		}

		public bool HashContainsEntry(string hashId, string key)
		{
			return this.TryCatch<bool>(() => this.client.HashContainsEntry(hashId, key), hashId);
		}

		public double IncrementItemInSortedSet(string setId, string value, double incrementBy)
		{
			return this.TryCatch<double>(() => this.client.IncrementItemInSortedSet(setId, value, incrementBy), setId);
		}

		public double IncrementItemInSortedSet(string setId, string value, long incrementBy)
		{
			return this.TryCatch<double>(() => this.client.IncrementItemInSortedSet(setId, value, incrementBy), setId);
		}

		public long IncrementValue(string key)
		{
			return this.TryCatch<long>(() => this.client.IncrementValue(key), key);
		}

		public long IncrementValueBy(string key, int count)
		{
			return this.TryCatch<long>(() => this.client.IncrementValueBy(key, count), key);
		}

		public long IncrementValueInHash(string hashId, string key, int incrementBy)
		{
			return this.TryCatch<long>(() => this.client.IncrementValueInHash(hashId, key, incrementBy), hashId);
		}

		public void MoveBetweenSets(string fromSetId, string toSetId, string item)
		{
			this.TryCatch(delegate
			{
				this.client.MoveBetweenSets(fromSetId, toSetId, item);
			}, fromSetId);
		}

		public string PopAndPushItemBetweenLists(string fromListId, string toListId)
		{
			return this.TryCatch<string>(() => this.client.PopAndPushItemBetweenLists(fromListId, toListId), fromListId);
		}

		public string PopItemFromList(string listId)
		{
			return this.TryCatch<string>(() => this.client.PopItemFromList(listId), listId);
		}

		public string PopItemFromSet(string setId)
		{
			return this.TryCatch<string>(() => this.client.PopItemFromSet(setId), setId);
		}

		public string PopItemWithHighestScoreFromSortedSet(string setId)
		{
			return this.TryCatch<string>(() => this.client.PopItemWithHighestScoreFromSortedSet(setId), setId);
		}

		public string PopItemWithLowestScoreFromSortedSet(string setId)
		{
			return this.TryCatch<string>(() => this.client.PopItemWithLowestScoreFromSortedSet(setId), setId);
		}

		public void PrependItemToList(string listId, string value)
		{
			this.TryCatch(delegate
			{
				this.client.PrependItemToList(listId, value);
			}, listId);
		}

		public void PrependRangeToList(string listId, List<string> values)
		{
			this.TryCatch(delegate
			{
				this.client.PrependRangeToList(listId, values);
			}, listId);
		}

		public long PublishMessage(string toChannel, string message)
		{
			return this.TryCatch<long>(() => this.client.PublishMessage(toChannel, message), string.Empty);
		}

		public void PushItemToList(string listId, string value)
		{
			this.TryCatch(delegate
			{
				this.client.PushItemToList(listId, value);
			}, listId);
		}

		public void RemoveAllFromList(string listId)
		{
			this.TryCatch(delegate
			{
				this.client.Remove(listId);
			}, listId);
		}

		public string RemoveEndFromList(string listId)
		{
			return this.TryCatch<string>(() => this.client.RemoveEndFromList(listId), listId);
		}

		public bool RemoveEntry(params string[] args)
		{
			return this.TryCatch<bool>(() => this.client.RemoveEntry(args), args[0]);
		}

		public bool RemoveEntryFromHash(string hashId, string key)
		{
			return this.TryCatch<bool>(() => this.client.RemoveEntryFromHash(hashId, key), hashId);
		}

		public long RemoveItemFromList(string listId, string value)
		{
			return this.TryCatch<long>(() => this.client.RemoveItemFromList(listId, value), listId);
		}

		public long RemoveItemFromList(string listId, string value, int noOfMatches)
		{
			return this.TryCatch<long>(() => this.client.RemoveItemFromList(listId, value, noOfMatches), listId);
		}

		public void RemoveItemFromSet(string setId, string item)
		{
			this.TryCatch(delegate
			{
				this.client.RemoveItemFromSet(setId, item);
			}, setId);
		}

		public bool RemoveItemFromSortedSet(string setId, string value)
		{
			return this.TryCatch<bool>(() => this.client.RemoveItemFromSortedSet(setId, value), setId);
		}
		/// <summary>
		///  骚操作-- redis 连接池-- 如果出现高并发,客户端的连接数量会上限,为了节省资源,重复利用连接对象,通过线程池去获取连接
		/// </summary>
		/// <param name="host"></param>
		/// <param name="port"></param>
		/// <param name="db"></param>
		/// <returns></returns>
		public static IRedisClientsManager GetPoolClient(string host, int port, int db)
		{
			return new PooledRedisClientManager(db, host + ":" + port);
		}
		public long RemoveRangeFromSortedSet(string setId, int minRank, int maxRank)
		{
			return this.TryCatch<long>(() => this.client.RemoveRangeFromSortedSet(setId, minRank, maxRank), setId);
		}

		public long RemoveRangeFromSortedSetByScore(string setId, double fromScore, double toScore)
		{
			return this.TryCatch<long>(() => this.client.RemoveRangeFromSortedSetByScore(setId, fromScore, toScore), setId);
		}

		public long RemoveRangeFromSortedSetByScore(string setId, long fromScore, long toScore)
		{
			return this.TryCatch<long>(() => this.client.RemoveRangeFromSortedSetByScore(setId, fromScore, toScore), setId);
		}

		public string RemoveStartFromList(string listId)
		{
			return this.TryCatch<string>(() => this.client.RemoveStartFromList(listId), listId);
		}

		public void RenameKey(string fromName, string toName)
		{
			this.TryCatch(delegate
			{
				this.client.RenameKey(fromName, toName);
			}, string.Empty);
		}

		public List<string> SearchKeys(string pattern)
		{
			return this.TryCatch<List<string>>(() => this.client.SearchKeys(pattern), pattern);
		}

		public void SetAll(Dictionary<string, string> map)
		{
			this.TryCatch(delegate
			{
				this.client.SetAll(map);
			}, string.Empty);
		}

		public void SetAll(IEnumerable<string> keys, IEnumerable<string> values)
		{
			this.TryCatch(delegate
			{
				this.client.SetAll(keys, values);
			}, string.Empty);
		}

		public bool SetContainsItem(string setId, string item)
		{
			return this.TryCatch<bool>(() => this.client.SetContainsItem(setId, item), setId);
		}

		public void SetEntry(string key, string value)
		{
			this.TryCatch(delegate
			{
				this.client.SetValue(key, value);
			}, key);
		}

		public void SetEntry(string key, string value, TimeSpan expireIn)
		{
			this.TryCatch(delegate
			{
				this.client.SetValue(key, value, expireIn);
			}, key);
		}

		public bool SetEntryIfNotExists(string key, string value)
		{
			return this.TryCatch<bool>(() => this.client.SetValueIfNotExists(key, value), key);
		}

		public bool SetEntryInHash(string hashId, string key, string value)
		{
			return this.TryCatch<bool>(() => this.client.SetEntryInHash(hashId, key, value), hashId);
		}

		public bool SetEntryInHashIfNotExists(string hashId, string key, string value)
		{
			return this.TryCatch<bool>(() => this.client.SetEntryInHashIfNotExists(hashId, key, value), hashId);
		}

		public void SetItemInList(string listId, int listIndex, string value)
		{
			this.TryCatch(delegate
			{
				this.client.SetItemInList(listId, listIndex, value);
			}, listId);
		}

		public void SetRangeInHash(string hashId, IEnumerable<KeyValuePair<string, string>> keyValuePairs)
		{
			this.TryCatch(delegate
			{
				this.client.SetRangeInHash(hashId, keyValuePairs);
			}, hashId);
		}

		public bool SortedSetContainsItem(string setId, string value)
		{
			return this.TryCatch<bool>(() => this.client.SortedSetContainsItem(setId, value), setId);
		}

		public void StoreAsHash<T>(T entity)
		{
			this.TryCatch(delegate
			{
				this.client.StoreAsHash<T>(entity);
			}, string.Empty);
		}


		public bool SetEntryInHash<T>(string hashId, string key, T value)
		{

			return this.TryCatch<bool>(() => this.client.SetEntryInHash(hashId, key, TextExtensions.SerializeToString<T>(value)), hashId);
		}
		public bool SetEntryInHash<T>(string hashId, string key, T value, TimeSpan expiresIn)
		{
			
			return this.TryCatch<bool>(() =>  this.client.SetEntryInHash(hashId, key, TextExtensions.SerializeToString<T>(value)), hashId);
		}
		public T GetValueFromHash<T>(string hashId, string key)
		{
			return this.TryCatch<T>(() => JsonSerializer.DeserializeFromString<T>(this.client.GetValueFromHash(hashId, key)), hashId);
		}

		public bool SetEntryInHashIfNotExists<T>(string hashId, string key, T value)
		{
			return this.TryCatch<bool>(() => this.client.SetEntryInHashIfNotExists(hashId, key, TextExtensions.SerializeToString<T>(value)), hashId);
		}

		public IDisposable AcquireLock(string key)
		{
			return this.TryCatch<IDisposable>(() => this.client.AcquireLock(key), key);
		}

		public IDisposable AcquireLock(string key, TimeSpan timeOut)
		{
			return this.TryCatch<IDisposable>(() => this.client.AcquireLock(key, timeOut), key);
		}


		public DateTime GetServerTime()
		{
			return this.TryCatch<DateTime>(() => this.client.GetServerTime(), string.Empty);
		}


	}
}