/// <summary> /// Add an index to the given dictionary of indexes, keyed by the given /// extractor. Also add the index as a listener to the given cache. /// </summary> /// <param name="extractor"> /// The IValueExtractor object that is used to extract an indexable /// property value from a cache entry. /// </param> /// <param name="ordered"> /// True if the contents of the indexed information should be ordered; /// false otherwise /// </param> /// <param name="comparator"> /// The IComparer object which imposes an ordering on entries in the /// indexed cache or <c>null</c> if the entries' values natural /// ordering should be used. /// </param> /// <param name="cache"> /// The cache that the newly created ICacheIndex will use for /// initialization and listen to for changes. /// </param> /// <param name="dictIndex"> /// The dictionary of indexes that the newly created ICacheIndex will /// be added to. /// </param> public static void AddIndex(IValueExtractor extractor, bool ordered, IComparer comparator, IObservableCache cache, IDictionary dictIndex) { var index = (ICacheIndex)dictIndex[extractor]; if (index == null) { for (int cAttempts = 4; ;) { if (extractor is IIndexAwareExtractor) { index = ((IIndexAwareExtractor)extractor). CreateIndex(ordered, comparator, dictIndex); if (index == null) { return; } } else { index = new SimpleCacheIndex(extractor, ordered, comparator); dictIndex[extractor] = index; } ICacheListener listener = EnsureListener(index); cache.AddCacheListener(listener, null, false); try { // build the index foreach (ICacheEntry entry in cache) { index.Insert(entry); } break; } catch (InvalidOperationException ioe) //collection was modified { cache.RemoveCacheListener(listener); if (--cAttempts == 0) { RemoveIndex(extractor, cache, dictIndex); CacheFactory.Log("Exception occured during index rebuild: " + ioe, CacheFactory.LogLevel.Error); throw; } } } } else if (!(ordered == index.IsOrdered && Equals(comparator, index.Comparer))) { throw new InvalidOperationException("Index for " + extractor + " already exists;" + " remove the index and add it with the new settings"); } }
public void ConverterObservableCacheTests() { IObservableCache cache = InstantiateCache(); IConverter cDown = new ConvertDown(); IConverter cUp = new ConvertUp(); TestCacheListener listener = new TestCacheListener(); IObservableCache convCache = ConverterCollections.GetObservableCache(cache, cUp, cDown, cUp, cDown); Assert.IsNotNull(convCache); //AddCacheListener(listener) convCache.AddCacheListener(listener); Assert.AreEqual(listener.inserted, 0); convCache.Add(1, 1); Assert.AreEqual(listener.inserted, 1); Assert.AreEqual(listener.updated, 0); convCache[1] = 2; Assert.AreEqual(listener.updated, 1); Assert.AreEqual(listener.deleted, 0); convCache.Remove(1); Assert.AreEqual(listener.deleted, 1); //RemoveCacheListener(listener) convCache.RemoveCacheListener(listener); Assert.AreEqual(listener.inserted, 1); convCache.Add(1, 1); Assert.AreEqual(listener.inserted, 1); listener.inserted = listener.updated = listener.deleted = 0; convCache.Clear(); //AddCacheListener(listener, key, isLite); convCache.AddCacheListener(listener, "1", true); for (int i = 0; i < 3; i++) { convCache.Add(i, i); } Assert.AreEqual(listener.inserted, 1); Assert.AreEqual(listener.updated, 0); Assert.AreEqual(listener.deleted, 0); for (int i = 0; i < 3; i++) { convCache[i] = i + 1; } Assert.AreEqual(listener.inserted, 1); Assert.AreEqual(listener.updated, 1); Assert.AreEqual(listener.deleted, 0); convCache.Clear(); Assert.AreEqual(listener.inserted, 1); Assert.AreEqual(listener.updated, 1); Assert.AreEqual(listener.deleted, 1); //RemoveCacheListener(listener, key) convCache.RemoveCacheListener(listener, "1"); convCache.Add(1, 1); Assert.AreEqual(listener.inserted, 1); listener.inserted = listener.updated = listener.deleted = 0; convCache.Clear(); IFilter filter = AlwaysFilter.Instance; //AddCacheListener(listener, filter, isLite) convCache.AddCacheListener(listener, filter, true); for (int i = 0; i < 3; i++) { convCache.Add(i, i); } Assert.AreEqual(listener.inserted, 3); Assert.AreEqual(listener.updated, 0); Assert.AreEqual(listener.deleted, 0); for (int i = 0; i < 3; i++) { convCache[i] = i + 1; } Assert.AreEqual(listener.inserted, 3); Assert.AreEqual(listener.updated, 3); Assert.AreEqual(listener.deleted, 0); convCache.Clear(); Assert.AreEqual(listener.inserted, 3); Assert.AreEqual(listener.updated, 3); Assert.AreEqual(listener.deleted, 3); //RemoveCacheListener(listener, filter) convCache.RemoveCacheListener(listener, filter); convCache.Add(1, 1); Assert.AreEqual(listener.inserted, 3); Assert.IsInstanceOf(typeof(ConverterCollections.ConverterObservableCache), convCache); ConverterCollections.ConverterObservableCache coc = convCache as ConverterCollections.ConverterObservableCache; Assert.IsNotNull(coc); Assert.AreEqual(coc.ObservableCache, cache); }