Si vous utilisez Stackechange.Redis, vous pouvez utiliser les méthodes List sur son API. Voici une implémentation naïve de IList utilisant une liste redis pour stocker les éléments.
J'espère que cela peut 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, puisque vous souhaitez accéder aux éléments par clé, je pense que vous recherchez des hachages Redis, qui sont des cartes composées de champs associés à des valeurs.
Vous pouvez donc avoir une Clé Redis pour un Hash contenant tous vos Clients, chacun étant une Valeur associée à un Champ. Vous pouvez choisir CustomerId comme champ, de sorte que vous puissiez ensuite obtenir un client par son identifiant dans O(1).
Je pense que l'implémentation d'IDictionary est un bon moyen de le voir fonctionner. Ainsi, une classe RedisDictionary similaire à RedisList mais utilisant un Redis Hash 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 peut être trouvée sur la bibliothèque CachingFramework.Redis.
Voici le code.
