示例#1
0
        public void Remember_ContextAndScopeAndReference_ShouldSubscripeToDisposedEventWhenScopeImplementsINotifyWhenDisposedAndClearCacheForTheScopeUponDispose()
        {
            var context            = _contextMock1.Object;
            var scope              = new DisposableScope();
            var cache              = CreateCache();
            var instance           = new object();
            var instanceReference1 = new InstanceReference {
                Instance = instance
            };
            var instanceReference2 = new InstanceReference {
                Instance = instance
            };

            Remember(cache, _contextMock1, new object(), _bindingConfigurationMock1.Object, instanceReference1);
            Remember(cache, _contextMock1, scope, _bindingConfigurationMock1.Object, instanceReference2);

            _pipelineMock.InSequence(_mockSequence).Setup(p => p.Deactivate(_contextMock1.Object, instanceReference2));

            Assert.Equal(2, cache.Count);

            scope.Dispose();

            Assert.Equal(1, cache.Count);
            Assert.Null(cache.TryGet(context, scope));

            _pipelineMock.Verify(p => p.Deactivate(_contextMock1.Object, instanceReference2));
        }
示例#2
0
        /// <summary>
        /// Asynchronously locks against the given key.
        /// </summary>
        /// <param name="key">
        /// The key that identifies the current object.
        /// </param>
        /// <returns>
        /// The disposable <see cref="Task"/>.
        /// </returns>
        public Task <IDisposable> LockAsync(object key)
        {
            DisposableScope releaser = new DisposableScope(
                key,
                s =>
            {
                SemaphoreSlim locker;
                if (SemaphoreSlims.TryRemove(s, out locker))
                {
                    locker.Release();
                    locker.Dispose();
                }
            });

            Task <IDisposable> releaserTask = Task.FromResult(releaser as IDisposable);
            SemaphoreSlim      semaphore    = SemaphoreSlims.GetOrAdd(key, new SemaphoreSlim(1, 1));

            Task waitTask = semaphore.WaitAsync();

            return(waitTask.IsCompleted
                       ? releaserTask
                       : waitTask.ContinueWith(
                       (_, r) => (IDisposable)r,
                       releaser,
                       CancellationToken.None,
                       TaskContinuationOptions.ExecuteSynchronously,
                       TaskScheduler.Default));
        }
        /// <summary>
        /// Asynchronously locks against the given key.
        /// </summary>
        /// <param name="key">
        /// The key that identifies the current object.
        /// </param>
        /// <returns>
        /// The disposable <see cref="Task"/>.
        /// </returns>
        public Task<IDisposable> LockAsync(object key)
        {
            DisposableScope releaser = new DisposableScope(
            key,
            s =>
            {
                SemaphoreSlim locker;
                if (SemaphoreSlims.TryRemove(s, out locker))
                {
                    locker.Release();
                    locker.Dispose();
                }
            });

            Task<IDisposable> releaserTask = Task.FromResult(releaser as IDisposable);
            SemaphoreSlim semaphore = SemaphoreSlims.GetOrAdd(key, new SemaphoreSlim(1, 1));

            Task waitTask = semaphore.WaitAsync();

            return waitTask.IsCompleted
                       ? releaserTask
                       : waitTask.ContinueWith(
                           (_, r) => (IDisposable)r,
                           releaser,
                           CancellationToken.None,
                           TaskContinuationOptions.ExecuteSynchronously,
                           TaskScheduler.Default);
        }
示例#4
0
 private static void Main(string[] args)
 {
     using (_proxy)
     {
         _proxy = new DisposableScope();
     }
 }
示例#5
0
        public static IDisposable GetIdentifiersOfMappedDocuments(this Index self, string startsWith, int start, int take, out IEnumerable <string> docIds)
        {
            if (self.Type.IsMapReduce() == false)
            {
                throw new NotSupportedException("Getting doc ids for map indexes is not supported");
            }

            using (var scope = new DisposableScope())
            {
                scope.EnsureDispose(self._contextPool.AllocateOperationContext(out TransactionOperationContext indexContext));

                RavenTransaction tx;
                scope.EnsureDispose(tx = indexContext.OpenReadTransaction());

                var tree = tx.InnerTransaction.ReadTree(MapReduceIndexBase <MapReduceIndexDefinition, IndexField> .MapPhaseTreeName);

                if (tree == null)
                {
                    docIds = Enumerable.Empty <string>();
                    return(scope);
                }

                TreeIterator it;
                scope.EnsureDispose(it = tree.Iterate(false));

                docIds = IterateKeys(it, startsWith, start, take, indexContext);

                return(scope.Delay());
            }
        }
示例#6
0
        private WeakReference RememberDisposableScope(Cache cache, Mock <IContext> contextMock, IBindingConfiguration bindingConfiguration, InstanceReference instanceReference)
        {
            var disposableScope = new DisposableScope();

            cache.Remember(contextMock.Object, disposableScope, instanceReference);

            return(new WeakReference(disposableScope));
        }
示例#7
0
        public static IDisposable Show(Form parentForm)
        {
            var f   = new InitializingUserPage(parentForm);
            var ret = new DisposableScope(f);

            new Thread(() => f.ShowDialog()).Start();

            return(ret);
        }
        internal IDisposable Push(object state)
        {
            lock ("scope")
            {
                var newScope = new DisposableScope(state.ToString(), this);

                m_AsyncSopes.Value.Add(newScope);

                return(newScope);
            }
        }
示例#9
0
        public IDisposable ReadPostponedActions(out IEnumerable <NotificationTableValue> actions, DateTime cutoff)
        {
            using (var scope = new DisposableScope())
            {
                scope.EnsureDispose(_contextPool.AllocateOperationContext(out TransactionOperationContext context));
                scope.EnsureDispose(context.OpenReadTransaction());

                actions = ReadPostponedActionsByPostponedUntilIndex(context, cutoff);

                return(scope.Delay());
            }
        }
示例#10
0
        public IDisposable ReadActionsOrderedByCreationDate(out IEnumerable <NotificationTableValue> actions)
        {
            using (var scope = new DisposableScope())
            {
                scope.EnsureDispose(_contextPool.AllocateOperationContext(out TransactionOperationContext context));
                scope.EnsureDispose(context.OpenReadTransaction());

                actions = ReadActionsByCreatedAtIndex(context);

                return(scope.Delay());
            }
        }
示例#11
0
        public IDisposable Read(string id, out NotificationTableValue value)
        {
            using (var scope = new DisposableScope())
            {
                RavenTransaction tx;

                scope.EnsureDispose(_contextPool.AllocateOperationContext(out TransactionOperationContext context));
                scope.EnsureDispose(tx = context.OpenReadTransaction());

                value = Get(id, context, tx);

                return(scope.Delay());
            }
        }
示例#12
0
        public IDisposable Push(object state)
        {
            lock ("scope")
            {
                if (m_AsyncSopes.Value == null)
                {
                    m_AsyncSopes.Value = new List <DisposableScope>();
                }

                var newScope = new DisposableScope(state.ToString(), this);

                m_AsyncSopes.Value.Add(newScope);

                return(newScope);
            }
        }
示例#13
0
        /// <summary>
        /// Locks against the given key.
        /// </summary>
        /// <param name="key">
        /// The key that identifies the current object.
        /// </param>
        /// <returns>
        /// The disposable <see cref="Task"/>.
        /// </returns>
        public IDisposable Lock(object key)
        {
            DisposableScope releaser = new DisposableScope(
            key,
            s =>
            {
                SemaphoreSlim locker;
                if (SemaphoreSlims.TryRemove(s, out locker))
                {
                    locker.Release();
                    locker.Dispose();
                }
            });

            SemaphoreSlim semaphore = SemaphoreSlims.GetOrAdd(key, new SemaphoreSlim(1, 1));
            semaphore.Wait();
            return releaser;
        }
示例#14
0
        /// <summary>
        /// Locks against the given key.
        /// </summary>
        /// <param name="key">
        /// The key that identifies the current object.
        /// </param>
        /// <returns>
        /// The disposable <see cref="Task"/>.
        /// </returns>
        public IDisposable Lock(object key)
        {
            DisposableScope releaser = new DisposableScope(
                key,
                s =>
            {
                SemaphoreSlim locker;
                if (SemaphoreSlims.TryRemove(s, out locker))
                {
                    locker.Release();
                    locker.Dispose();
                }
            });

            SemaphoreSlim semaphore = SemaphoreSlims.GetOrAdd(key, new SemaphoreSlim(1, 1));

            semaphore.Wait();
            return(releaser);
        }
示例#15
0
    public static IDisposable Lock(object key)
    {
        // Get the current info or create a new one
        var info = activeLocks.AddOrUpdate(key,
                                           (k) => new LockInfo(),
                                           (k, v) => v.Enter() ? v : new LockInfo());
        DisposableScope releaser = new DisposableScope(() =>
        {
            if (info.Exit())
            {
                // Only remove this exact info, in case another thread has
                // already put its own info into the dictionary
                ((ICollection <KeyValuePair <object, LockInfo> >)activeLocks)
                .Remove(new KeyValuePair <object, LockInfo>(key, info));
            }
        });

        return(releaser);
    }
示例#16
0
        public static IDisposable GetReduceTree(this Index self, string[] docIds, out IEnumerable <ReduceTree> trees)
        {
            using (var scope = new DisposableScope())
            {
                scope.EnsureDispose(self._contextPool.AllocateOperationContext(out TransactionOperationContext indexContext));

                RavenTransaction tx;
                scope.EnsureDispose(tx = indexContext.OpenReadTransaction());

                var mapPhaseTree = tx.InnerTransaction.ReadTree(MapReduceIndexBase <MapReduceIndexDefinition, IndexField> .MapPhaseTreeName);

                if (mapPhaseTree == null)
                {
                    trees = Enumerable.Empty <ReduceTree>();
                    return(scope);
                }

                var reducePhaseTree = tx.InnerTransaction.ReadTree(MapReduceIndexBase <MapReduceIndexDefinition, IndexField> .ReducePhaseTreeName);

                if (reducePhaseTree == null)
                {
                    trees = Enumerable.Empty <ReduceTree>();
                    return(scope);
                }

                var mapEntries = new List <FixedSizeTree>(docIds.Length);
                foreach (var docId in docIds)
                {
                    FixedSizeTree mapEntriesTree;
                    scope.EnsureDispose(mapEntriesTree = mapPhaseTree.FixedTreeFor(docId.ToLower(), sizeof(long)));
                    mapEntries.Add(mapEntriesTree);
                }

                FixedSizeTree typePerHash;
                scope.EnsureDispose(typePerHash = reducePhaseTree.FixedTreeFor(MapReduceIndexBase <MapReduceIndexDefinition, IndexField> .ResultsStoreTypesTreeName, sizeof(byte)));

                trees = IterateTrees(self, mapEntries, reducePhaseTree, typePerHash, indexContext, scope);

                return(scope.Delay());
            }
        }
示例#17
0
        private static IEnumerable <ReduceTree> IterateTrees(Index self, List <FixedSizeTree> mapEntries,
                                                             Tree reducePhaseTree, FixedSizeTree typePerHash, TransactionOperationContext indexContext, DisposableScope scope)
        {
            var reduceKeys    = new HashSet <ulong>();
            var idToDocIdHash = new Dictionary <long, string>();

            foreach (var tree in mapEntries)
            {
                foreach (var mapEntry in MapReduceIndexBase <MapReduceIndexDefinition, IndexField> .GetMapEntries(tree))
                {
                    reduceKeys.Add(mapEntry.ReduceKeyHash);
                    idToDocIdHash[mapEntry.Id] = tree.Name.ToString();
                }
            }

            foreach (var reduceKeyHash in reduceKeys)
            {
                MapReduceResultsStore store;

                var mapReduceIndex = self as MapReduceIndex;

                if (mapReduceIndex != null)
                {
                    store = mapReduceIndex.CreateResultsStore(typePerHash,
                                                              reduceKeyHash, indexContext, false);
                }
                else
                {
                    store = ((AutoMapReduceIndex)self).CreateResultsStore(typePerHash,
                                                                          reduceKeyHash, indexContext, false);
                }

                using (store)
                {
                    ReduceTree tree;
                    switch (store.Type)
                    {
                    case MapResultsStorageType.Tree:
                        tree = RenderTree(store.Tree, reduceKeyHash, idToDocIdHash, self, indexContext);
                        break;

                    case MapResultsStorageType.Nested:
                        tree = RenderNestedSection(store.GetNestedResultsSection(reducePhaseTree), reduceKeyHash, idToDocIdHash, self,
                                                   indexContext);
                        break;

                    default:
                        throw new ArgumentOutOfRangeException(store.Type.ToString());
                    }

                    scope.EnsureDispose(tree);
                    yield return(tree);
                }
            }
        }
 public AsyncLock()
 {
     _releaser     = new DisposableScope(() => _semaphore.Release());
     _releaserTask = Task.FromResult(_releaser as IDisposable);
 }