Comment stocker un élément de liste dans le cache Redis
J'ai utilisé StackExchange.Redis pour le cache c # redis.
cache.StringSet("Key1", CustomerObject);
mais je veux stocker des données comme
cache.StringSet("Key1", ListOfCustomer);
de sorte qu'une clé ait toute la liste de clients stockée et qu'il est facile de rechercher, grouper, filtrer les données client également dans cette liste
Les réponses sont les bienvenues avec ServiceStack.Redis ou StackExchange.Redis
Vous pouvez utiliser ServiceStack.Redis high-level API typée IRedisTypedClient pour gérer des types POCO riches.
Commencez par obtenir un client Redis dactylographié pour les clients avec:
var redisCustomers = redis.As<Customer>();
Ce qui résoudra une API typée de haut niveau pour la gestion des POCO clients, qui vous permettra ensuite de conserver un client unique avec:
redisCustomers.SetEntry("Customer1", CustomerObject);
Ou une liste de clients avec:
redisCustomers.Lists["Customers"].AddRange(ListOfCustomer);
Si vous utilisez Stackechange.Redis , vous pouvez utiliser les méthodes List de son API . Voici une implémentation naïve de IList utilisant une liste redis pour stocker les éléments.
Espérons que cela puisse vous aider à comprendre certaines des méthodes de l'API de liste:
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());
}
}
}
Notez l'utilisation de Newtonsoft.Json pour la sérialisation . Vous aurez besoin des packages nu-get suivants:
Install-Package Newtonsoft.Json
Install-Package StackExchange.Redis
Après avoir lu votre question et vos commentaires, étant donné que vous souhaitez accéder aux éléments par clé, je pense que vous recherchez Redis Hashes , qui sont des cartes composées de champs associés à des valeurs.
Vous pouvez donc avoir une clé Redis pour un hachage contenant tous vos clients, chacun étant une valeur associée à un champ. Vous pouvez choisir le CustomerId comme champ afin que vous puissiez ensuite obtenir un client par son identifiant dans O (1).
Je pense qu'implémenter IDictionary est un bon moyen de le voir fonctionner ..__ Donc, une classe RedisDictionary similaire à RedisList mais utilisant un hachage Redis pourrait être:
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());
}
}
Et voici quelques exemples pour l'utiliser:
// 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];
Mise à jour (octobre 2015)
Une meilleure implémentation de ces collections est disponible dans la bibliothèque CachingFramework.Redis .
Ici est le code.
StackExchange.Redis a déjà des fonctions prédéfinies pour gérer les listes et les ensembles de valeurs.
Obtenir l'objet IDatabase:
string cacheConnection = Utils.Sections.Storage.RedisCache.ConnectionString;
IDatabase cache = ConnectionMultiplexer.Connect (cacheConnection) .GetDatabase ();
méthodes de liste:
cache.ListLeftPushAsync (clé, valeurs) -> Ajout d'une liste d'éléments
cache.ListRangeAsync (key, startIndex, endIndex) -> obtenir la liste des valeurs
cache.KeyExpire (clé, timspan)
veuillez empaqueter StackExchange.Redis pour plus de méthodes. Vous n'avez pas besoin d'inclure de paquet de pépites supplémentaire.