Un'API "fortemente tipizzata" disponibile sul client Redis C# di Service Stack per applicare tutte le operazioni Redis Value a qualsiasi tipo c#
API client generica fortemente tipizzata #
Di seguito è riportata l'API fortemente tipizzata a cui hai accesso dopo aver chiamato IRedisClient.As<T>() es.:
using (var redisClient = new RedisClient())
{
var redis = redisClient.As<MyPocoType>();
}
La variabile redis ora contiene un client generico fortemente tipizzato che consente l'applicazione delle operazioni sui valori Redis rispetto a MyPocoType . L'interfaccia seguente elenca tutte le operazioni disponibili:
public interface IRedisTypedClient<T>
: IBasicPersistenceProvider<T>
{
IHasNamed<IRedisList<T>> Lists { get; set; }
IHasNamed<IRedisSet<T>> Sets { get; set; }
IHasNamed<IRedisSortedSet<T>> SortedSets { get; set; }
IRedisHash<TKey, T> GetHash<TKey>(string hashId);
IRedisTypedTransaction<T> CreateTransaction();
IDisposable AcquireLock();
IDisposable AcquireLock(TimeSpan timeOut);
int Db { get; set; }
List<string> GetAllKeys();
T this[string key] { get; set; }
string SequenceKey { get; set; }
void SetSequence(int value);
int GetNextSequence();
RedisKeyType GetEntryType(string key);
string GetRandomKey();
void SetEntry(string key, T value);
void SetEntry(string key, T value, TimeSpan expireIn);
bool SetEntryIfNotExists(string key, T value);
T GetValue(string key);
T GetAndSetValue(string key, T value);
bool ContainsKey(string key);
bool RemoveEntry(string key);
bool RemoveEntry(params string[] args);
bool RemoveEntry(params IHasStringId[] entities);
int IncrementValue(string key);
int IncrementValueBy(string key, int count);
int DecrementValue(string key);
int DecrementValueBy(string key, int count);
bool ExpireEntryIn(string key, TimeSpan expiresAt);
bool ExpireEntryAt(string key, DateTime dateTime);
TimeSpan GetTimeToLive(string key);
void Save();
void SaveAsync();
void FlushDb();
void FlushAll();
T[] SearchKeys(string pattern);
List<T> GetValues(List<string> keys);
List<T> GetSortedEntryValues(IRedisSet<T> fromSet, int startingFrom, int endingAt);
HashSet<T> GetAllItemsFromSet(IRedisSet<T> fromSet);
void AddItemToSet(IRedisSet<T> toSet, T item);
void RemoveItemFromSet(IRedisSet<T> fromSet, T item);
T PopItemFromSet(IRedisSet<T> fromSet);
void MoveBetweenSets(IRedisSet<T> fromSet, IRedisSet<T> toSet, T item);
int GetSetCount(IRedisSet<T> set);
bool SetContainsItem(IRedisSet<T> set, T item);
HashSet<T> GetIntersectFromSets(params IRedisSet<T>[] sets);
void StoreIntersectFromSets(IRedisSet<T> intoSet, params IRedisSet<T>[] sets);
HashSet<T> GetUnionFromSets(params IRedisSet<T>[] sets);
void StoreUnionFromSets(IRedisSet<T> intoSet, params IRedisSet<T>[] sets);
HashSet<T> GetDifferencesFromSet(IRedisSet<T> fromSet, params IRedisSet<T>[] withSets);
void StoreDifferencesFromSet(IRedisSet<T> intoSet, IRedisSet<T> fromSet, params IRedisSet<T>[] withSets);
T GetRandomItemFromSet(IRedisSet<T> fromSet);
List<T> GetAllItemsFromList(IRedisList<T> fromList);
List<T> GetRangeFromList(IRedisList<T> fromList, int startingFrom, int endingAt);
List<T> SortList(IRedisList<T> fromList, int startingFrom, int endingAt);
void AddItemToList(IRedisList<T> fromList, T value);
void PrependItemToList(IRedisList<T> fromList, T value);
T RemoveStartFromList(IRedisList<T> fromList);
T BlockingRemoveStartFromList(IRedisList<T> fromList, TimeSpan? timeOut);
T RemoveEndFromList(IRedisList<T> fromList);
void RemoveAllFromList(IRedisList<T> fromList);
void TrimList(IRedisList<T> fromList, int keepStartingFrom, int keepEndingAt);
int RemoveItemFromList(IRedisList<T> fromList, T value);
int RemoveItemFromList(IRedisList<T> fromList, T value, int noOfMatches);
int GetListCount(IRedisList<T> fromList);
T GetItemFromList(IRedisList<T> fromList, int listIndex);
void SetItemInList(IRedisList<T> toList, int listIndex, T value);
//Queue operations
void EnqueueItemOnList(IRedisList<T> fromList, T item);
T DequeueItemFromList(IRedisList<T> fromList);
T BlockingDequeueItemFromList(IRedisList<T> fromList, TimeSpan? timeOut);
//Stack operations
void PushItemToList(IRedisList<T> fromList, T item);
T PopItemFromList(IRedisList<T> fromList);
T BlockingPopItemFromList(IRedisList<T> fromList, TimeSpan? timeOut);
T PopAndPushItemBetweenLists(IRedisList<T> fromList, IRedisList<T> toList);
void AddItemToSortedSet(IRedisSortedSet<T> toSet, T value);
void AddItemToSortedSet(IRedisSortedSet<T> toSet, T value, double score);
bool RemoveItemFromSortedSet(IRedisSortedSet<T> fromSet, T value);
T PopItemWithLowestScoreFromSortedSet(IRedisSortedSet<T> fromSet);
T PopItemWithHighestScoreFromSortedSet(IRedisSortedSet<T> fromSet);
bool SortedSetContainsItem(IRedisSortedSet<T> set, T value);
double IncrementItemInSortedSet(IRedisSortedSet<T> set, T value, double incrementBy);
int GetItemIndexInSortedSet(IRedisSortedSet<T> set, T value);
int GetItemIndexInSortedSetDesc(IRedisSortedSet<T> set, T value);
List<T> GetAllItemsFromSortedSet(IRedisSortedSet<T> set);
List<T> GetAllItemsFromSortedSetDesc(IRedisSortedSet<T> set);
List<T> GetRangeFromSortedSet(IRedisSortedSet<T> set, int fromRank, int toRank);
List<T> GetRangeFromSortedSetDesc(IRedisSortedSet<T> set, int fromRank, int toRank);
IDictionary<T, double> GetAllWithScoresFromSortedSet(IRedisSortedSet<T> set);
IDictionary<T, double> GetRangeWithScoresFromSortedSet(IRedisSortedSet<T> set, int fromRank, int toRank);
IDictionary<T, double> GetRangeWithScoresFromSortedSetDesc(IRedisSortedSet<T> set, int fromRank, int toRank);
List<T> GetRangeFromSortedSetByLowestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore);
List<T> GetRangeFromSortedSetByLowestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore, int? skip, int? take);
List<T> GetRangeFromSortedSetByLowestScore(IRedisSortedSet<T> set, double fromScore, double toScore);
List<T> GetRangeFromSortedSetByLowestScore(IRedisSortedSet<T> set, double fromScore, double toScore, int? skip, int? take);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByLowestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByLowestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore, int? skip, int? take);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByLowestScore(IRedisSortedSet<T> set, double fromScore, double toScore);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByLowestScore(IRedisSortedSet<T> set, double fromScore, double toScore, int? skip, int? take);
List<T> GetRangeFromSortedSetByHighestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore);
List<T> GetRangeFromSortedSetByHighestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore, int? skip, int? take);
List<T> GetRangeFromSortedSetByHighestScore(IRedisSortedSet<T> set, double fromScore, double toScore);
List<T> GetRangeFromSortedSetByHighestScore(IRedisSortedSet<T> set, double fromScore, double toScore, int? skip, int? take);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByHighestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByHighestScore(IRedisSortedSet<T> set, string fromStringScore, string toStringScore, int? skip, int? take);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByHighestScore(IRedisSortedSet<T> set, double fromScore, double toScore);
IDictionary<T, double> GetRangeWithScoresFromSortedSetByHighestScore(IRedisSortedSet<T> set, double fromScore, double toScore, int? skip, int? take);
int RemoveRangeFromSortedSet(IRedisSortedSet<T> set, int minRank, int maxRank);
int RemoveRangeFromSortedSetByScore(IRedisSortedSet<T> set, double fromScore, double toScore);
int GetSortedSetCount(IRedisSortedSet<T> set);
double GetItemScoreInSortedSet(IRedisSortedSet<T> set, T value);
int StoreIntersectFromSortedSets(IRedisSortedSet<T> intoSetId, params IRedisSortedSet<T>[] setIds);
int StoreUnionFromSortedSets(IRedisSortedSet<T> intoSetId, params IRedisSortedSet<T>[] setIds);
bool HashContainsEntry<TKey>(IRedisHash<TKey, T> hash, TKey key);
bool SetEntryInHash<TKey>(IRedisHash<TKey, T> hash, TKey key, T value);
bool SetEntryInHashIfNotExists<TKey>(IRedisHash<TKey, T> hash, TKey key, T value);
void SetRangeInHash<TKey>(IRedisHash<TKey, T> hash, IEnumerable<KeyValuePair<TKey, T>> keyValuePairs);
T GetValueFromHash<TKey>(IRedisHash<TKey, T> hash, TKey key);
bool RemoveEntryFromHash<TKey>(IRedisHash<TKey, T> hash, TKey key);
int GetHashCount<TKey>(IRedisHash<TKey, T> hash);
List<TKey> GetHashKeys<TKey>(IRedisHash<TKey, T> hash);
List<T> GetHashValues<TKey>(IRedisHash<TKey, T> hash);
Dictionary<TKey, T> GetAllEntriesFromHash<TKey>(IRedisHash<TKey, T> hash);
}
Interfaccia di accesso ai dati comuni #
Compresi i metodi di cui sopra, il client generico implementa anche operazioni di accesso ai dati comuni non specifiche di Redis che possono essere facilmente implementate da altri fornitori di persistenza dei dati se si desidera scambiare fornitori in futuro.
public interface IBasicPersistenceProvider<T>
: IDisposable
{
T GetById(string id);
IList<T> GetByIds(ICollection<string> ids);
IList<T> GetAll();
T Store(T entity);
void StoreAll(IEnumerable<T> entities);
void Delete(T entity);
void DeleteById(string id);
void DeleteByIds(ICollection<string> ids);
void DeleteAll();
}
In generale, se hai solo esigenze di persistenza di base, consiglierei di sviluppare contro l'API di accesso ai dati comune di cui sopra poiché è più facile da implementare per altri provider di persistenza e aumenta la probabilità che la tua libreria possa essere riutilizzata così com'è per persistere contro altri archivi di dati cioè contro un RDBMS con OrmLite, ecc.
