public List <SVR_AniDB_File> GetByInternalVersion(int version) { using (CacheLock.ReaderLock()) { return(IsCached ? InternalVersions.GetMultiple(version) : Table.Where(a => a.InternalVersion == version).ToList()); } }
public void Remove(IEnumerable <T> data) { CacheLock.Write(Lock, () => { primaryCache.Remove(data); secondaryCaches.Remove(data); }); }
private void AddKeysToNoDataCache <TU>(IEnumerable <TU> keys, ReaderWriterLockSlim @lock) { var filteredKeys = keys.ToList(); filteredKeys.RemoveAll(k => noDataCache.Contains(k)); CacheLock.Write(@lock, () => noDataCache.Update(filteredKeys)); }
protected override void ExitLock() { if (CacheLock.IsReadLockHeld) { CacheLock.ExitReadLock(); } }
public object GetCacheItem(string cacheName, string key, params object[] args) { TkDebug.AssertArgumentNullOrEmpty(cacheName, "cacheName", this); TkDebug.AssertArgumentNullOrEmpty(key, "key", this); ICache cache = GetCache(cacheName); BaseCacheItemCreator creator = PlugInFactoryManager.CreateInstance <BaseCacheItemCreator>( CacheItemCreatorPlugInFactory.REG_NAME, cacheName); TkDebug.AssertNotNull(creator, $"{cacheName}不存在", this); if (cache == null) { ICacheCreator cacheCreator = creator.CacheCreator; if (cacheCreator == null) { cacheCreator = creator.SupportDistributed ? DefaultDistributedCreator : DefaultCreator; } cache = cacheCreator.CreateCache(cacheName); CacheLock.WriteLockAction(() => { if (!fCaches.ContainsKey(cacheName)) { fCaches.Add(cacheName, cache); return(true); } return(false); }); } return(cache.GetItem(creator.TransformCacheKey(key), creator, args)); }
private static async Task <T> GetAsync <T>(this ObjectCache cache, string key, Func <Task <T> > acquireAsync, Action <string, object> set) { string cacheKey = CacheKeyGenerator.GenerateCacheKey <T>(key); if (cache.IsSet(cacheKey)) { var acquiredValue = cache.Get(cacheKey); if (acquiredValue is NullObject) { return(default(T)); } return((T)acquiredValue); } using (await CacheLock.LockAsync(cacheKey)) { if (cache.IsSet(cacheKey)) { return((T)cache.Get(cacheKey)); } var acquiredValue = await acquireAsync(); if (acquiredValue != null) { set(cacheKey, acquiredValue); } else { set(cacheKey, NullObject.Instance); } return(acquiredValue); } }
public AniDB_Tag GetByTagID(int id) { using (CacheLock.ReaderLock()) { return(IsCached ? Tags.GetOne(id) : Table.FirstOrDefault(a => a.TagID == id)); } }
public void EscalateLock() { if (!CacheLock.TryEnterWriteLock(_timeOut)) { ThrowTimeoutException("escalated write"); } }
internal override void RegenerateDb(IProgress <RegenerateProgress> progress) { List <AniDB_Episode> episodes; using (CacheLock.ReaderLock()) { episodes = IsCached ? Cache.Values.Where(episode => episode.EnglishName.Contains('`') || episode.RomajiName.Contains('`')).ToList() : Table.Where((episode => episode.EnglishName.Contains('`') || episode.RomajiName.Contains('`'))).ToList(); } using (IAtomic <List <AniDB_Episode>, object> update = BeginAtomicBatchUpdate(episodes)) { RegenerateProgress regen = new RegenerateProgress(); regen.Title = "Fixing Episode Titles"; regen.Step = 0; regen.Total = update.Updatable.Count; foreach (AniDB_Episode episode in update.Updatable) { episode.EnglishName = episode.EnglishName.Replace('`', '\''); episode.RomajiName = episode.RomajiName.Replace('`', '\''); regen.Step++; progress.Report(regen); } update.Commit(); regen.Step = regen.Total; progress.Report(regen); } }
private ICache GetCache(string cacheName) { ICache cache; cache = CacheLock.ReadLockAction(() => ObjectUtil.TryGetValue(fCaches, cacheName)); return(cache); }
public List <AniDB_Vote> GetByEntity(int entID) { using (CacheLock.ReaderLock()) { return(IsCached ? EntityIDs.GetMultiple(entID)?.ToList() : Table.Where(a => a.EntityID == entID).ToList()); } }
public SVR_AniDB_File GetByMD5(string hash) { using (CacheLock.ReaderLock()) { return(IsCached ? MD5s.GetOne(hash) : Table.FirstOrDefault(a => a.MD5 == hash)); } }
public List <SVR_AniDB_File> GetByAnimeID(int animeID) { using (CacheLock.ReaderLock()) { return(IsCached ? Animes.GetMultiple(animeID) : Table.Where(a => a.AnimeID == animeID).ToList()); } }
public List <SVR_AniDB_File> GetByResolution(string res) { using (CacheLock.ReaderLock()) { return(IsCached ? Resolutions.GetMultiple(res) : Table.Where(a => a.File_VideoResolution == res).ToList()); } }
public SVR_AniDB_File GetByFileID(int fileID) { using (CacheLock.ReaderLock()) { return(IsCached ? FileIds.GetOne(fileID) : Table.FirstOrDefault(a => a.FileID == fileID)); } }
public SVR_AniDB_File GetByHashAndFileSize(string hash, long fsize) { using (CacheLock.ReaderLock()) { return(IsCached ? Hashes.GetMultiple(hash).FirstOrDefault(a => a.FileSize == fsize) : Table.FirstOrDefault(a => a.Hash == hash && a.FileSize == fsize)); } }
protected override void ExitLock() { if (CacheLock.IsWriteLockHeld) { CacheLock.ExitWriteLock(); } }
private void UpdateCache(IEnumerable <T> data) { CacheLock.Write(Lock, () => { primaryCache.Update(data); secondaryCaches.Update(data); }); }
/* public override void SaveOLD(SVR_AniDB_Anime obj) { lock (globalDBLock) { lock (obj) { if (obj.AniDB_AnimeID == 0) { obj.Contract = null; base.Save(obj); } using (var session = DatabaseFactory.SessionFactory.OpenSession()) { obj.UpdateContractDetailed(session.Wrap()); } // populate the database base.Save(obj); } } } */ public SVR_AniDB_Anime GetByAnimeID(int id) { using (CacheLock.ReaderLock()) { if (IsCached) return Animes.GetOne(id); return Table.FirstOrDefault(a => a.AnimeID == id); } }
public void Dispose() { CacheLock.Dispose(); foreach (var item in fCaches.Values) { item.DisposeObject(); } fCaches.Clear(); }
public RepositoryCacheUpgradeableLock(Guid repositoryId, ReaderWriterLockSlim cacheLock, int timeOut) : base(repositoryId, cacheLock) { if (!CacheLock.TryEnterUpgradeableReadLock(timeOut)) { ThrowTimeoutException("upgradeable read"); } _timeOut = timeOut; }
private void InitializeCache(IEnumerable <T> data) { CacheLock.Write(Lock, () => { primaryCache.Initialize(data); secondaryCaches.Initialize(data); cacheStorageStrategy.Save("Primary", primaryCache); cacheStorageStrategy.Save("Secondary", secondaryCaches); }); }
/// <summary> /// Clear all cached values /// </summary> public void Clear() { CacheLock.EnterWriteLock(); try { Cache.Clear(); } finally { CacheLock.ExitWriteLock(); } }
/// <summary> /// Count all cached values /// </summary> /// <returns></returns> public int Count() { CacheLock.EnterReadLock(); try { return(Cache.Count); } finally { CacheLock.ExitReadLock(); } }
public void LockTest() { var userCount = 1 * 1000; var storageMaxCount = userCount; var cache = new TestCacheUserStorage(storageMaxCount); cache.BeginUnloadCount = int.MaxValue; cache.StopUnloadCount = int.MaxValue; cache.CreateUsers(userCount); var users = cache.GetAllUsers(); var request = new CacheRequest() { ObjectId = users.First().Id }; CacheLock lockObj = null; // чтение потом запись var readObj1 = cache.Read(request); lockObj = ((TestCacheUserWriteObject)readObj1).Response.Lock; Assert.False(lockObj.IsEntered()); using (var writeObj = cache.Write(request)) { Assert.True(lockObj.IsEntered()); } Assert.False(lockObj.IsEntered()); // запись потом чтение using (var writeObj1 = cache.Write(request)) { Assert.True(lockObj.IsEntered()); var readObj2 = cache.Read(request); Assert.True(lockObj.IsEntered()); Assert.True(lockObj.IsEntered()); } Assert.False(lockObj.IsEntered()); // чтение потом чтение using (var writeObj1 = cache.Write(request)) { Assert.True(lockObj.IsEntered()); Assert.Equal(1, lockObj.Count); using (var writeObj2 = cache.Write(request)) { Assert.True(lockObj.IsEntered()); Assert.Equal(2, lockObj.Count); Assert.True(ReferenceEquals(writeObj1, writeObj2)); } Assert.True(lockObj.IsEntered()); Assert.Equal(1, lockObj.Count); } Assert.False(lockObj.IsEntered()); Assert.Equal(0, lockObj.Count); }
private void CheckCacheLock(CacheLock original, CacheLock copy) { Assert.That(copy.Version, Is.EqualTo(original.Version)); Assert.That(copy.Version, Is.TypeOf(original.Version.GetType())); Assert.That(copy.Id, Is.EqualTo(original.Id)); Assert.That(copy.Multiplicity, Is.EqualTo(original.Multiplicity)); Assert.That(copy.Timeout, Is.EqualTo(original.Timeout)); Assert.That(copy.UnlockTimestamp, Is.EqualTo(original.UnlockTimestamp)); Assert.That(copy.WasLockedConcurrently, Is.EqualTo(original.WasLockedConcurrently)); }
/// <summary> /// Remove cached value /// </summary> /// <param name="key">Cache key</param> public void Remove(TKey key) { RevokeExpires(); CacheLock.EnterWriteLock(); try { Cache.Remove(key); } finally { CacheLock.ExitWriteLock(); } }
public AniDB_Episode GetByEpisodeID(int id) { using (CacheLock.ReaderLock()) { if (IsCached) { return(EpisodesIds.GetOne(id)); } return(Table.FirstOrDefault(a => a.EpisodeID == id)); } }
public List <AniDB_Episode> GetByAnimeIDAndEpisodeTypeNumber(int animeid, EpisodeType epType, int epnumber) { using (CacheLock.ReaderLock()) { if (IsCached) { return(Animes.GetMultiple(animeid).Where(a => a.EpisodeNumber == epnumber && a.GetEpisodeTypeEnum() == epType).ToList()); } return(Table.Where(a => a.AnimeID == animeid && a.EpisodeNumber == epnumber && a.EpisodeType == (int)epType).ToList()); } }
public List <AniDB_Episode> GetByAnimeID(int id) { using (CacheLock.ReaderLock()) { if (IsCached) { return(Animes.GetMultiple(id)); } return(Table.Where(a => a.AnimeID == id).ToList()); } }