private void DisposeManaged()
{
Stop(true);
_workerCTS?.Dispose();
_workerTask?.Dispose();
_ratesLock?.Dispose();
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_lock?.Dispose();
}
}
public void Dispose()
{
if (_cacheLock == null)
{
return;
}
_cacheLock.EnterWriteLock();
try
{
var services = _innerCache.Values.ToArray();
foreach (var service in services)
{
var disposable = service as IDisposable;
disposable?.Dispose();
}
_innerCache.Clear();
}
finally
{
_cacheLock.ExitWriteLock();
_cacheLock?.Dispose();
_cacheLock = null;
}
}
public void Dispose()
{
if (_scheduler != null)
{
_scheduler.Subscribe -= SchedulerOnSubscribe;
}
_readerWriterLock?.Dispose();
}
/// <inheritdoc />
public void Dispose()
{
if (_isDisposed)
{
return;
}
_isDisposed = true;
_locker?.Dispose();
_locker = null;
}
/// <summary>
/// Disposes the <see cref="ConcurrentCollection{T}"/> with the internal <see cref="ReaderWriterLockSlim"/> object.
/// </summary>
public void Dispose()
{
try
{
_lock?.Dispose();
}
catch
{
}
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="alsoManaged"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
private void Dispose(bool alsoManaged)
{
if (IsDisposed)
{
return;
}
IsDisposed = true;
Locker?.Dispose();
Locker = null;
}
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
_locker.Dispose();
}
_disposedValue = true;
}
}
public void Dispose()
{
if (_treeLock != null)
{
Debug.Assert(!_treeLock.IsWriteLockHeld);
Debug.Assert(!_treeLock.IsReadLockHeld);
_treeLock.Dispose();
_treeLock = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (_lock != null)
{
_lock.Dispose();
_lock = null;
}
}
}
public void Dispose_WithWriteLock()
{
var rwl = new ReaderWriterLockSlim();
rwl.EnterWriteLock();
try {
rwl.Dispose();
Assert.Fail("1");
} catch (SynchronizationLockException) {
}
}
public void EntersWriteLock()
{
var slim = new ReaderWriterLockSlim();
var token = slim.Write();
Assert.IsTrue(slim.IsWriteLockHeld);
slim.ExitWriteLock();
slim.Dispose();
}
protected virtual void Dispose(bool Disposing)
{
OnCompleted();
if (Disposing)
{
ViewModel?.Dispose();
_readWriteLock?.Dispose();
_snapshotLock?.Dispose();
}
_isDisposed = true;
}
public void ExitsWriteLock()
{
var slim = new ReaderWriterLockSlim();
var token = slim.Read();
token.Dispose();
Assert.IsFalse(slim.IsReadLockHeld);
slim.Dispose();
}
/// <summary>
/// Disposes this instance by freeing all the owned entries.
/// </summary>
/// <param name="disposeManaged">See <see cref="Disposable.Dispose(bool)"/>.</param>
protected override void Dispose(bool disposeManaged)
{
if (disposeManaged)
{
//
// Itt ne "this.Where()"-t hivjunk mert az feleslegesen lock-olna.
//
foreach (IDisposable disposable in FEntries.Values.Where(ShouldDispose))
{
disposable.Dispose();
}
FEntries.Clear();
FLock.Dispose();
}
base.Dispose(disposeManaged);
}
public void Dispose()
{
if (_isDisposed)
{
return;
}
_isDisposed = true;
_lock.Dispose();
_cancellationTokenSource.Dispose();
}
protected virtual void Dispose(bool disposing)
{
if (_isDisposed || !disposing)
{
return;
}
_isDisposed = true;
State.ParseRequest -= ReparseRequested;
Cancel(false);
ParsingSuspendLock.Dispose();
}
// The bulk of the clean-up code is implemented in Dispose(bool)
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// free managed resources
if (rwl != null)
{
rwl.Dispose();
rwl = null;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (!m_objectDisposed)
{
if (disposing)
{
m_dataUnitsLock.Dispose();
}
m_objectDisposed = true;
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (!_isDisposed)
{
_isDisposed = true;
_lock.Dispose();
_lock = null;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (!hasDisposed)
{
if (disposing)
{
_processLock.Dispose();
}
hasDisposed = true;
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing && !_disposed)
{
if (_rwLock != null)
{
_rwLock.Dispose();
}
_rwLock = null;
_disposed = true;
}
}
public void Dispose()
{
if (_isDisposed)
{
return;
}
_sha256?.Dispose();
_lock?.Dispose();
_isDisposed = true;
}
private void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
cancelToken.Cancel();
_locker.Dispose();
}
disposed = true;
}
}
/// <summary>
/// Protected vitual member of the dispose pattern.
/// </summary>
/// <param name="disposing">Call came from Dispose.</param>
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
_lock.Dispose();
}
_disposed = true;
}
}
// The bulk of the clean-up code is implemented in Dispose(bool)
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// free managed resources
if (slimLock != null)
{
slimLock.Dispose();
slimLock = null;
}
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
public void Dispose()
{
Stop();
if (_blockingCollection != null)
{
_blockingCollection.Dispose();
}
if (_lock != null)
{
_lock.Dispose();
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
public void Dispose()
{
Stop();
if (_queue != null)
{
_queue.Clear();
}
if (_lock != null)
{
_lock.Dispose();
}
}
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
rwlock.Dispose();
}
disposed = true;
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_readerWriterLock.Dispose();
}
disposedValue = true;
}
}
public static void Dispose()
{
ReaderWriterLockSlim rwls;
rwls = new ReaderWriterLockSlim();
rwls.Dispose();
Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterReadLock(0));
Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterUpgradeableReadLock(0));
Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterWriteLock(0));
rwls.Dispose();
for (int i = 0; i < 3; i++)
{
rwls = new ReaderWriterLockSlim();
switch (i)
{
case 0: rwls.EnterReadLock(); break;
case 1: rwls.EnterUpgradeableReadLock(); break;
case 2: rwls.EnterWriteLock(); break;
}
Assert.Throws<SynchronizationLockException>(() => rwls.Dispose());
}
}