[REDIS] 레디 스 캐시에있는 목록 요소를 저장하는 방법

레디 스 캐시에있는 목록 요소를 저장하는 방법

전 C # 레디 스 캐시 StackExchange.Redis을 사용했다.

cache.StringSet("Key1", CustomerObject);

하지만 같은 데이터를 저장할

cache.StringSet("Key1", ListOfCustomer);

답변 ServiceStack.Redis 또는 StackExchange.Redis을 사용하실 수 있습니다

해결법

1. ==============================

   1.당신은 풍부한 POCO 유형을 관리하기위한 ServiceStack.Redis의 높은 수준의 IRedisTypedClient 형식화 된 API를 사용할 수 있습니다.

   당신은 풍부한 POCO 유형을 관리하기위한 ServiceStack.Redis의 높은 수준의 IRedisTypedClient 형식화 된 API를 사용할 수 있습니다.

   첫째로 고객을위한 입력 레디 스 클라이언트를 얻을 :

   var redisCustomers = redis.As<Customer>();
   

   고객 POCO의 다음 하나의 고객과 함께 지속 할 수 있음을 관리하기위한 높은 수준의 입력 API를 해결할 수있는 :

   redisCustomers.SetEntry("Customer1", CustomerObject);
   

   또는 사용하는 고객의 목록 :

   redisCustomers.Lists["Customers"].AddRange(ListOfCustomer);
   

2. ==============================

   2.당신이 Stackexchange.Redis를 사용하는 경우, 당신은 API의 목록 방법을 사용할 수 있습니다. 여기에 항목을 저장하는 레디 스 목록을 사용하여 IList의의 순진 구현입니다.

   당신이 Stackexchange.Redis를 사용하는 경우, 당신은 API의 목록 방법을 사용할 수 있습니다. 여기에 항목을 저장하는 레디 스 목록을 사용하여 IList의의 순진 구현입니다.

   희망이 목록 API의 몇 가지 방법을 이해하는 데 도움이 될 수 있습니다 :

   public class RedisList<T> : IList<T>
   {
       private static ConnectionMultiplexer _cnn;
       private string key;
       public RedisList(string key)
       {
           this.key = key;
           _cnn = ConnectionMultiplexer.Connect("localhost");
       }
       private IDatabase GetRedisDb()
       {
           return _cnn.GetDatabase();
       }
       private string Serialize(object obj)
       {
           return JsonConvert.SerializeObject(obj);
       }
       private T Deserialize<T>(string serialized)
       {
           return JsonConvert.DeserializeObject<T>(serialized);
       }
       public void Insert(int index, T item)
       {
           var db = GetRedisDb();
           var before = db.ListGetByIndex(key, index);
           db.ListInsertBefore(key, before, Serialize(item));
       }
       public void RemoveAt(int index)
       {
           var db = GetRedisDb();
           var value = db.ListGetByIndex(key, index);
           if (!value.IsNull)
           {
               db.ListRemove(key, value);
           }
       }
       public T this[int index]
       {
           get
           {
               var value = GetRedisDb().ListGetByIndex(key, index);
               return Deserialize<T>(value.ToString());
           }
           set
           {
               Insert(index, value);
           }
       }
       public void Add(T item)
       {
           GetRedisDb().ListRightPush(key, Serialize(item));
       }
       public void Clear()
       {
           GetRedisDb().KeyDelete(key);
       }
       public bool Contains(T item)
       {
           for (int i = 0; i < Count; i++)
           {
               if (GetRedisDb().ListGetByIndex(key, i).ToString().Equals(Serialize(item)))
               {
                   return true;
               }
           }
           return false;
       }
       public void CopyTo(T[] array, int arrayIndex)
       {
           GetRedisDb().ListRange(key).CopyTo(array, arrayIndex);
       }
       public int IndexOf(T item)
       {
           for (int i = 0; i < Count; i++)
           {
               if (GetRedisDb().ListGetByIndex(key, i).ToString().Equals(Serialize(item)))
               {
                   return i;
               }
           }
           return -1;
       }
       public int Count
       {
           get { return (int)GetRedisDb().ListLength(key); }
       }
       public bool IsReadOnly
       {
           get { return false; }
       }
       public bool Remove(T item)
       {
           return GetRedisDb().ListRemove(key, Serialize(item)) > 0;
       }
       public IEnumerator<T> GetEnumerator()
       {
           for (int i = 0; i < this.Count; i++)
           {
               yield return Deserialize<T>(GetRedisDb().ListGetByIndex(key, i).ToString());
           }
       }
       System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
       {
           for (int i = 0; i < this.Count; i++)
           {
               yield return Deserialize<T>(GetRedisDb().ListGetByIndex(key, i).ToString());
           }
       }
   }
   

   직렬화에 대한 Newtonsoft.Json의 사용을합니다. 다음 뉴-GET 패키지가 필요합니다 :

   Install-Package Newtonsoft.Json
   Install-Package StackExchange.Redis
   

   당신이 키에 의해 액세스 요소를 원하기 때문에 당신의 질문과 의견을 읽은 후, 나는 당신이 값과 관련된 필드로 구성지도입니다 레디 스 해시, 찾고 생각합니다.

   당신은 모든 고객을 포함하는 해시에 대한 레디 스 키를 가질 수 있도록하는 가치 하나 하나는 필드에 관련. 당신이 다음 O (1)에서 ID로 고객을 얻을 수 있도록, 필드와 고객 ID를 선택할 수 있습니다.

   나는 IDictionary를 구현하는 작업을 볼 수있는 좋은 방법이라고 생각합니다. RedisList하지만 될 수있는 레디 스 해시를 사용하여 비슷한 RedisDictionary 클래스 그래서 :

   public class RedisDictionary<TKey, TValue> : IDictionary<TKey, TValue>
   {
       private static ConnectionMultiplexer _cnn;
       private string _redisKey;
       public RedisDictionary(string redisKey)
       {
           _redisKey = redisKey;
           _cnn = ConnectionMultiplexer.Connect("localhost");
       }
       private IDatabase GetRedisDb()
       {
           return _cnn.GetDatabase();
       }
       private string Serialize(object obj)
       {
           return JsonConvert.SerializeObject(obj);
       }
       private T Deserialize<T>(string serialized)
       {
           return JsonConvert.DeserializeObject<T>(serialized);
       }
       public void Add(TKey key, TValue value)
       {
           GetRedisDb().HashSet(_redisKey, Serialize(key), Serialize(value));
       }
       public bool ContainsKey(TKey key)
       {
           return GetRedisDb().HashExists(_redisKey, Serialize(key));
       }
       public bool Remove(TKey key)
       {
           return GetRedisDb().HashDelete(_redisKey, Serialize(key));
       }
       public bool TryGetValue(TKey key, out TValue value)
       {
           var redisValue = GetRedisDb().HashGet(_redisKey, Serialize(key));
           if (redisValue.IsNull)
           {
               value = default(TValue);
               return false;
           }
           value = Deserialize<TValue>(redisValue.ToString());
           return true;
       }
       public ICollection<TValue> Values
       {
           get { return new Collection<TValue>(GetRedisDb().HashValues(_redisKey).Select(h => Deserialize<TValue>(h.ToString())).ToList()); }
       }
       public ICollection<TKey> Keys
       {
           get { return new Collection<TKey>(GetRedisDb().HashKeys(_redisKey).Select(h => Deserialize<TKey>(h.ToString())).ToList()); }
       }
       public TValue this[TKey key]
       {
           get
           {
               var redisValue = GetRedisDb().HashGet(_redisKey, Serialize(key));
               return redisValue.IsNull ? default(TValue) : Deserialize<TValue>(redisValue.ToString());
           }
           set
           {
               Add(key, value);
           }
       }
       public void Add(KeyValuePair<TKey, TValue> item)
       {
           Add(item.Key, item.Value);
       }
       public void Clear()
       {
           GetRedisDb().KeyDelete(_redisKey);
       }
       public bool Contains(KeyValuePair<TKey, TValue> item)
       {
           return GetRedisDb().HashExists(_redisKey, Serialize(item.Key));
       }
       public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
       {
           GetRedisDb().HashGetAll(_redisKey).CopyTo(array, arrayIndex);
       }
       public int Count
       {
           get { return (int)GetRedisDb().HashLength(_redisKey); }
       }
       public bool IsReadOnly
       {
           get { return false; }
       }
       public bool Remove(KeyValuePair<TKey, TValue> item)
       {
           return Remove(item.Key);
       }
       public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
       {
           var db = GetRedisDb();
           foreach (var hashKey in db.HashKeys(_redisKey))
           {
               var redisValue = db.HashGet(_redisKey, hashKey);
               yield return new KeyValuePair<TKey, TValue>(Deserialize<TKey>(hashKey.ToString()), Deserialize<TValue>(redisValue.ToString()));
           }
       }
       System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
       {
           yield return GetEnumerator();
       }
       public void AddMultiple(IEnumerable<KeyValuePair<TKey, TValue>> items)
       {
           GetRedisDb()
               .HashSet(_redisKey, items.Select(i => new HashEntry(Serialize(i.Key), Serialize(i.Value))).ToArray());
       }
   }
   

   그리고 여기에 그것을 사용하는 몇 가지 예입니다 :

   // Insert customers to the cache            
   var customers = new RedisDictionary<int, Customer>("customers");
   customers.Add(100, new Customer() { Id = 100, Name = "John" });
   customers.Add(200, new Customer() { Id = 200, Name = "Peter" });
   
   // Or if you have a list of customers retrieved from DB:
   IList<Customer> customerListFromDb;
   customers.AddMultiple(customerListFromDb.ToDictionary(k => k.Id));
   
   // Query a customer by its id
   var customers = new RedisDictionary<int, Customer>("customers");
   Customer customer100 = customers[100];
   

   이러한 컬렉션의 더 나은 구현은 CachingFramework.Redis 라이브러리에서 찾을 수 있습니다.

   여기에 코드입니다.

3. ==============================

   3.StackExchange.Redis 이미 목록 처리하는 기능을 미리 정의하고 값으로 설정하고있다.

   StackExchange.Redis 이미 목록 처리하는 기능을 미리 정의하고 값으로 설정하고있다.

   IDatabase 개체를 가져옵니다 :

   문자열 cacheConnection = Utils.Sections.Storage.RedisCache.ConnectionString;

   IDatabase 캐시 = ConnectionMultiplexer.Connect (cacheConnection) .GetDatabase ();

   목록의 방법 :

   cache.ListLeftPushAsync (키 값) -> 요소들의리스트의 한 푸시

   cache.ListRangeAsync (키에서 startIndex, endIndex에이) -> 값의 목록을

   만료 cache.Key (키, 시간 범위)

   이상의 방법에 대한 StackExchange.Redis 패키지하시기 바랍니다. 당신은 여분의 nuget 패키지를 포함 할 필요가 없습니다.

from https://stackoverflow.com/questions/31955977/how-to-store-list-element-in-redis-cache by cc-by-sa and MIT license