public void DisposedOnIsValueCreatedTest() { var tl = new ThreadLocal <int>(); tl.Dispose(); GC.KeepAlive(tl.IsValueCreated); }
public void Run() { var someDisposable = Substitute.For <IDisposable>(); someDisposable.DidNotReceive().Dispose(); var threadLocal = new ThreadLocal <IDisposable>(() => someDisposable); threadLocal.IsValueCreated.ShouldBeFalse(); threadLocal.Value.ShouldBe(someDisposable); threadLocal.IsValueCreated.ShouldBeTrue(); threadLocal.ToString().ShouldStartWith("Substitute.IDisposable|"); threadLocal.Dispose(); Should.Throw <ObjectDisposedException>(() => threadLocal.Value.ShouldBe(someDisposable)) .Message.ShouldBe("Cannot access a disposed object.\r\nObject name: 'The ThreadLocal object has been disposed.'."); someDisposable.DidNotReceive().Dispose(); var threadLocalDisposable = new ThreadLocalDisposable <IDisposable>(() => someDisposable); threadLocalDisposable.IsValueCreated.ShouldBeFalse(); threadLocalDisposable.Value.ShouldBe(someDisposable); threadLocalDisposable.IsValueCreated.ShouldBeTrue(); threadLocalDisposable.ToString().ShouldStartWith("Substitute.IDisposable|"); threadLocalDisposable.Dispose(); Should.Throw <ObjectDisposedException>(() => threadLocalDisposable.Value.ShouldBe(someDisposable)) .Message.ShouldBe("Cannot access a disposed object.\r\nObject name: 'The ThreadLocal object has been disposed.'."); someDisposable.Received(1).Dispose(); }
private void Dispose(bool disposing) { if (_isDisposed) { return; } _timerSubscription?.Dispose(); _meterInformation.Dispose(); _simpleAudioVolume.Dispose(); _deviceMutedSubscription.Dispose(); _muteChanged.Dispose(); _stateChanged.Dispose(); _disconnected.Dispose(); _volumeChanged.Dispose(); _peakValueChanged.Dispose(); //Run this on the com thread to ensure it's disposed correctly ComThread.BeginInvoke(() => { AudioSessionControl.UnregisterAudioSessionNotification(this); }).ContinueWith(x => { _audioSessionControl.Dispose(); }); GC.SuppressFinalize(this); _isDisposed = true; }
//~FileManager() //{ // Dispose(); //} public void Dispose() { foreach (var viewWrap in _allWraps) { viewWrap._va.Dispose(); } _vw.Dispose(); GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); GC.WaitForPendingFinalizers(); try { FileMutex.WaitOne(); CloseMapFile(); if (PersistenceMode == PersistenceMode.TemporaryPersist) { var count = _tempSemaphore.Release(); // if no more access to the file, then delete it if (count == _MAX_SHARED_ACCESS - 1) { DeleteBackingFileIfExists(_fileName); } _tempSemaphore.Dispose(); } } finally { FileMutex.ReleaseMutex(); } FileMutex.Dispose(); }
public void Dispose() { _localCommitted.Dispose(); _localDeletedCollection.Dispose(); _localModifiedCollection.Dispose(); _localNewCollection.Dispose(); }
private void DisposeWindows(bool isDisposing) { AssertDisposing(_state); if (isDisposing) { var threadWindows = _windows.Values; for (var i = 0; i < threadWindows.Count; i++) { var windows = threadWindows[i]; if (windows != null) { var hWnds = windows.Keys; foreach (var hWnd in hWnds) { var dispatchProvider = Win32DispatchProvider.Instance; var window = RemoveWindow(windows, hWnd); window.Dispose(); } Assert(AssertionsEnabled && (windows.Count == 0)); } } _windows.Dispose(); } }
protected override void Dispose(bool disposing) { _committed.Dispose(); _newEntities.Dispose(); _modifiedEntities.Dispose(); _deletedEntities.Dispose(); }
public override void Dispose() { adjacentSimsTL.Dispose(); lerpLeftRightTL.Dispose(); lerpTopBotTL.Dispose(); base.Dispose(); }
public void Dispose() { disposerLock.EnterWriteLock(); try { if (databasesCleanupTimer != null) { databasesCleanupTimer.Dispose(); } if (listener != null && listener.IsListening) { listener.Stop(); } disposed = true; lock (ResourcesStoresCache) { foreach (var documentDatabase in ResourcesStoresCache) { documentDatabase.Value.Dispose(); } ResourcesStoresCache.Clear(); } currentConfiguration.Dispose(); currentDatabase.Dispose(); currentTenantId.Dispose(); } finally { disposerLock.ExitWriteLock(); } }
protected virtual void Dispose(bool disposing) { if (disposing) { foreach (var viewWrap in _allWraps) { viewWrap._va.Dispose(); } _vw.Dispose(); } try { FileMutex.WaitOne(); CloseMapFile(); if (PersistenceMode == PersistenceMode.TemporaryPersist) { var count = _tempSemaphore.Release(); // if no more access to the file, then delete it if (count == _MAX_SHARED_ACCESS - 1) { DeleteBackingFileIfExists(_fileName); } _tempSemaphore.Dispose(); } } finally { FileMutex.ReleaseMutex(); } FileMutex.Dispose(); }
public void DisposedOnValueTest() { var tl = new ThreadLocal <int>(); tl.Dispose(); GC.KeepAlive(tl.Value); }
public void Dispose() { shouldNotifyOnWork.Dispose(); if (DocsPerSecCounter != null) { DocsPerSecCounter.Dispose(); } if (ReducedPerSecCounter != null) { ReducedPerSecCounter.Dispose(); } if (RequestsPerSecCounter != null) { RequestsPerSecCounter.Dispose(); } if (ConcurrentRequestsCounter != null) { ConcurrentRequestsCounter.Dispose(); } if (IndexedPerSecCounter != null) { IndexedPerSecCounter.Dispose(); } cancellationTokenSource.Dispose(); }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> /// <filterpriority>2</filterpriority> public void Dispose() { ThreadLocal <List <T> > local = _local; if (local == null) { return; } if (_values != null) { return; } Debug.Assert(local.Values != null); T[] values = local.Values.SelectMany(l => l).ToArray(); if (_values != null) { return; } _values = values; _local = null; local.Dispose(); }
public void Dispose() { _localCommitted.Dispose(); _localDeletedList.Dispose(); _localModifiedList.Dispose(); _localNewList.Dispose(); }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// /// <param name="disposing"><c>true</c> to release both managed /// and unmanaged resources; <c>false</c> to release only unmanaged /// resources.</param> /// protected virtual void Dispose(bool disposing) { if (disposing) { // free managed resources if (inputs != null) inputs.Dispose(); if (outputs != null) outputs.Dispose(); if (logLikelihoods != null) logLikelihoods.Dispose(); if (gradient != null) gradient.Dispose(); if (lnZx != null) lnZx.Dispose(); if (lnZxy != null) lnZxy.Dispose(); if (error != null) error.Dispose(); inputs = null; outputs = null; gradient = null; logLikelihoods = null; lnZxy = null; lnZx = null; error = null; } }
public void Dispose() { disposerLock.EnterWriteLock(); try { if (disposed) { return; } disposed = true; current.Dispose(); if (documentCacher != null) { documentCacher.Dispose(); } if (idleTimer != null) { idleTimer.Dispose(); } if (persistenceSource != null) { persistenceSource.Dispose(); } if (tableStroage != null) { tableStroage.Dispose(); } } finally { disposerLock.ExitWriteLock(); } }
public MainWindow() { InitializeComponent(); ThreadLocal <string> threadName = new ThreadLocal <string>(() => { return("Thread" + Thread.CurrentThread.ManagedThreadId); }); Action action = () => { bool repeat = threadName.IsValueCreated; tb.Text = string.Format("ThreadName = {0} {1}", threadName.Value, repeat ? "(repeat)" : ""); }; Parallel.Invoke(action, action, action, action); threadName.Dispose(); //List<string> vs = new List<string> //{ // "abc", // "def" //}; //var vb = vs.Select(x => x != null); }
private void DisposeWindows(bool isDisposing) { AssertDisposing(_state); if (isDisposing) { var threadWindows = _windows.Values; for (var i = 0; i < threadWindows.Count; i++) { var windows = threadWindows[i]; if (windows is not null) { var windowHandles = windows.Keys; foreach (var windowHandle in windowHandles) { var dispatchService = XlibDispatchService.Instance; var window = RemoveWindow(windows, dispatchService.Display, windowHandle, dispatchService); window.Dispose(); } Assert(AssertionsEnabled && (windows.Count == 0)); } } _windows.Dispose(); } }
/// <summary> /// Release any contained resources. /// </summary> /// <param name="disposing">set this to true if releasing managed resources</param> protected virtual void Dispose(bool disposing) { if (!disposing) { return; } if (!m_ownPoller && !m_poller.IsStarted) { DisposeSynced(); return; } // disposing on the scheduler thread var task = new Task(DisposeSynced); task.Start(this); task.Wait(); // poller cannot be stopped from poller thread if (m_ownPoller) { m_poller.CancelAndJoin(); m_poller.Dispose(); } m_schedulerThread.Dispose(); }
/// <summary> /// Reset cached value /// </summary> /// <remarks> /// Resets the cache for all threads /// </remarks> public void ResetCache() { ThreadLocal <CacheEntry> oldCacheEntry = this.localCacheEntry; this.localCacheEntry = new ThreadLocal <CacheEntry>(); oldCacheEntry?.Dispose(); }
public void DisposedOnValueTest() { var tl = new ThreadLocal <int> (); tl.Dispose(); var value = tl.Value; }
/// <summary> /// Disposing. /// </summary> /// <param name="disposing"></param> protected virtual void Dispose(bool disposing) { if (_randomGen != null && _randomGen.IsValueCreated && _randomGen.Value != null) { _randomGen.Dispose(); } }
public void Dispose() { disposerLock.EnterWriteLock(); try { if (disposed) { return; } disposed = true; var exceptionAggregator = new ExceptionAggregator("Could not properly dispose TransactionalStorage"); exceptionAggregator.Execute(() => current.Dispose()); if (tableStorage != null) { exceptionAggregator.Execute(() => tableStorage.Dispose()); } if (bufferPool != null) { exceptionAggregator.Execute(() => bufferPool.Dispose()); } exceptionAggregator.ThrowIfNeeded(); } finally { disposerLock.ExitWriteLock(); } }
static void Main(string[] args) { //var test = new ThreadLocal<Test>(() => // { return new Test(); } //); var test = new ThreadLocal <ITest>(trackAllValues: true); Action actionA = () => { test.Value = new TestA(); //Console.WriteLine($"The test id is {test.Value.Id}"); }; Action actionB = () => { test.Value = new TestB(); }; //Action action = () => // { // //bool isCreated = threadName.IsValueCreated; // //Console.WriteLine(threadName.Value + (isCreated ? ("Repeated"):"")); // //number.Value = Guid.NewGuid(); // Console.WriteLine($"{test.Value.Id} threadId is: {Thread.CurrentThread.ManagedThreadId}."); // }; Parallel.Invoke(actionA, actionB, actionB, actionA, actionB, actionA, actionA, actionB, actionB); test.Values.ToList().ForEach(v => Console.WriteLine(v.GetType())); test.Dispose(); Console.Read(); }
public void DisposedOnIsValueCreatedTest() { var tl = new ThreadLocal <int> (); tl.Dispose(); var value = tl.IsValueCreated; }
private void DisposeWindows(bool isDisposing) { _state.AssertDisposing(); if (isDisposing) { var threadWindows = _windows.Values; for (var i = 0; i < threadWindows.Count; i++) { var windows = threadWindows[i]; if (windows != null) { var windowHandles = windows.Keys; foreach (var windowHandle in windowHandles) { var dispatchProvider = UI.DispatchProvider.Instance; var window = RemoveWindow(windows, dispatchProvider.Display, windowHandle, dispatchProvider); window.Dispose(); } Assert(windows.Count == 0, Resources.ArgumentOutOfRangeExceptionMessage, nameof(windows.Count), windows.Count); } } _windows.Dispose(); } }
internal static void Dispose() { CachedGuidBuffer.Values.ForEach(Marshal.FreeHGlobal); Current.Dispose(); Cache.Dispose(); CacheManagedOnly.Dispose(); }
public void Dispose() { disposerLock.EnterWriteLock(); try { if (disposed) { return; } disposed = true; current.Dispose(); if (tableStorage != null) { tableStorage.Dispose(); } if (bufferPool != null) { bufferPool.Dispose(); } } finally { disposerLock.ExitWriteLock(); } }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { _shouldStop = true; WorkExists(); _workerThread.Join(); _canary.Dispose(); }
internal void Clear(bool dispose) { lock (AllSubscriptions) { if (_disposed) { return; } AllSubscriptions.Clear(); for (var i = 0; i < _localSubscriptions.Values.Count; i++) { _localSubscriptions.Values[i].Clear(); } if (dispose) { _localSubscriptionRevision.Dispose(); _localSubscriptions.Dispose(); _disposed = true; } else { _subscriptionsChangeCounter++; } } }
public void PlayWithThreadLocal() { var threadName = new ThreadLocal<string>(() => Thread.CurrentThread.ManagedThreadId.ToString()); Action action = () => { var repeat = threadName.IsValueCreated ? "(repeat)" : ""; var name = threadName.Value; Console.Out.WriteLine("name = {0} {1}", name, repeat); }; Parallel.Invoke(action, action, action, action, action, action, action, action); threadName.Dispose(); }
public void DisposedOnValueTest() { var tl = new ThreadLocal<int>(); tl.Dispose(); var value = tl.Value; }
public void DisposedOnIsValueCreatedTest() { var tl = new ThreadLocal<int>(); tl.Dispose(); var value = tl.IsValueCreated; }
private static bool RunThreadLocalTest5_Dispose() { TestHarness.TestLog("* RunThreadLocalTest5_Dispose()"); ThreadLocal<string> tl = new ThreadLocal<string>(() => "dispose test"); string value = tl.Value; tl.Dispose(); if (!TestHarnessAssert.EnsureExceptionThrown(() => { string tmp = tl.Value; }, typeof(ObjectDisposedException), "The Value property of the disposed ThreadLocal object should throw ODE")) return false; if (!TestHarnessAssert.EnsureExceptionThrown(() => { bool tmp = tl.IsValueCreated; }, typeof(ObjectDisposedException), "The IsValueCreated property of the disposed ThreadLocal object should throw ODE")) return false; if (!TestHarnessAssert.EnsureExceptionThrown(() => { string tmp = tl.ToString(); }, typeof(ObjectDisposedException), "The ToString method of the disposed ThreadLocal object should throw ODE")) return false; // test recycling the combination index; tl = new ThreadLocal<string>(() => null); if(tl.IsValueCreated) { TestHarness.TestLog("* Filed, reusing the same index kept the old value and didn't use the new value."); return false; } if (tl.Value != null) { TestHarness.TestLog("* Filed, reusing the same index kept the old value and didn't use the new value."); return false; } return true; }
private static void RunThreadLocalTest8Helper(ManualResetEventSlim mres) { var tl = new ThreadLocal<object>(true); var t = Task.Run(() => tl.Value = new SetMreOnFinalize(mres)); t.Wait(); t = null; GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); Assert.True(tl.Values.Count == 1, "RunThreadLocalTest8_Values: Expected other thread to have set value"); Assert.True(tl.Values[0] is SetMreOnFinalize, "RunThreadLocalTest8_Values: Expected other thread's value to be of the right type"); tl.Dispose(); object values; Assert.Throws<ObjectDisposedException>(() => values = tl.Values); }
public static void RunThreadLocalTest8_Values() { // Test adding values and updating values { var threadLocal = new ThreadLocal<int>(true); Assert.True(threadLocal.Values.Count == 0, "RunThreadLocalTest8_Values: Expected thread local to initially have 0 values"); Assert.True(threadLocal.Value == 0, "RunThreadLocalTest8_Values: Expected initial value of 0"); Assert.True(threadLocal.Values.Count == 1, "RunThreadLocalTest8_Values: Expected values count to now be 1 from initialized value"); Assert.True(threadLocal.Values[0] == 0, "RunThreadLocalTest8_Values: Expected values to contain initialized value"); threadLocal.Value = 42; Assert.True(threadLocal.Values.Count == 1, "RunThreadLocalTest8_Values: Expected values count to still be 1 after updating existing value"); Assert.True(threadLocal.Values[0] == 42, "RunThreadLocalTest8_Values: Expected values to contain updated value"); ((IAsyncResult)Task.Run(() => threadLocal.Value = 43)).AsyncWaitHandle.WaitOne(); Assert.True(threadLocal.Values.Count == 2, "RunThreadLocalTest8_Values: Expected values count to be 2 now that another thread stored a value"); Assert.True(threadLocal.Values.Contains(42) && threadLocal.Values.Contains(43), "RunThreadLocalTest8_Values: Expected values to contain both thread's values"); int numTasks = 1000; Task[] allTasks = new Task[numTasks]; for (int i = 0; i < numTasks; i++) { // We are creating the task using TaskCreationOptions.LongRunning because... // there is no guarantee that the Task will be created on another thread. // There is also no guarantee that using this TaskCreationOption will force // it to be run on another thread. var task = Task.Factory.StartNew(() => threadLocal.Value = i, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); task.Wait(); } var values = threadLocal.Values; Assert.True(values.Count == 1002, "RunThreadLocalTest8_Values: Expected values to contain both previous values and 1000 new values"); for (int i = 0; i < 1000; i++) { Assert.True(values.Contains(i), "RunThreadLocalTest8_Values: Expected values to contain value for thread #: " + i); } threadLocal.Dispose(); } // Test that thread values remain after threads depart { var tl = new ThreadLocal<string>(true); var t = Task.Run(() => tl.Value = "Parallel"); t.Wait(); t = null; GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); Assert.True(tl.Values.Count == 1, "RunThreadLocalTest8_Values: Expected values count to be 1 from other thread's initialization"); Assert.True(tl.Values.Contains("Parallel"), "RunThreadLocalTest8_Values: Expected values to contain 'Parallel'"); } }
public static void RunThreadLocalTest5_Dispose_Negative() { ThreadLocal<string> tl = new ThreadLocal<string>(() => "dispose test"); string value = tl.Value; tl.Dispose(); Assert.Throws<ObjectDisposedException>(() => { string tmp = tl.Value; }); // Failure Case: The Value property of the disposed ThreadLocal object should throw ODE Assert.Throws<ObjectDisposedException>(() => { bool tmp = tl.IsValueCreated; }); // Failure Case: The IsValueCreated property of the disposed ThreadLocal object should throw ODE Assert.Throws<ObjectDisposedException>(() => { string tmp = tl.ToString(); }); // Failure Case: The ToString method of the disposed ThreadLocal object should throw ODE }