public void Dispose()
{
if (!IsDisposed)
{
IsDisposed = true;
Disposed?.Invoke(this, EventArgs.Empty);
}
}
public void Dispose()
{
InputStream = null;
OutputStream = null;
StreamSocket.Dispose();
StreamSocket = null;
Disposed?.Invoke(this, null);
}
protected override void PostConstruct()
{
base.PostConstruct();
OnChange
.TakeUntil(Disposed.Where(identity))
.Subscribe(Apply, this);
}
public void Push(object message)
{
if (ShouldDispose())
{
_disposeCount++;
Disposed.Raise(this);
}
}
/// <summary>
/// Inheritors implement the <see cref="Dispose(bool)"/> method to dispose resources accordingly, depending on whether they have been called proactively
/// or automatically via the finalizer.
/// </summary>
/// <param name="disposing">
/// True when called proactively, i.e. Not during garbage collection. Managed resources should not be accessed when this is False, just references and
/// unmanaged resources released.
/// </param>
protected virtual void Dispose(bool disposing)
{
// Set second flag to indicate disposed state
IsDisposed = true;
// Fire Disposed event
Disposed?.Invoke(this, EventArgs.Empty);
}
public void Dispose()
{
if (AutoSaveChanges)
{
SaveChanges();
}
Disposed?.Invoke(this, EventArgs.Empty);
}
void OnFree(int handle, int channel, int data, IntPtr User)
{
IsDisposed = true;
if (Disposed != null)
{
Disposed.Invoke(this, new EventArgs());
}
}
protected virtual void OnDisposed()
{
if (Disposed == null)
{
return;
}
Disposed.Invoke(this, new EventArgs());
}
public void Dispose()
{
if (!disposing)
{
disposing = true;
Disposed?.Invoke(this, EventArgs.Empty);
}
}
public void Dispose()
{
// Spellchecker first, because it uses _index
Spellchecker.Dispose();
State?.Dispose();
Disposed?.Invoke();
}
protected virtual void Dispose(bool disposing)
{
if (disposing && _baseFile != null)
{
_baseFile.Dispose();
Disposed?.Invoke(this, EventArgs.Empty);
}
}
protected virtual void Dispose(bool disposing)
{
if (isDisposed)
{
return;
}
isDisposed = true;
Disposed?.Invoke(this, EventArgs.Empty);
}
public async System.Threading.Tasks.Task OnDisposed()
{
if (Disposing != null)
{
await Disposing();
}
Disposed?.Invoke();
Disposing = null; Disposed = null;
}
/// <summary>
/// Releases the unmanaged resources used by the System.ComponentModel.Component
/// and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">
/// true to release both managed and unmanaged resources; false to release only unmanaged
/// resources.
/// </param>
protected virtual void Dispose(bool disposing)
{
foreach (IChatbot chatbot in this)
{
chatbot.Dispose();
}
Disposed?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged 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)
{
Disposed?.Invoke(this, EventArgs.Empty);
}
WNetCancelConnection2(_networkName, 0, true);
}
/// <inheritdoc/>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
Disposed?.Invoke(this, EventArgs.Empty);
}
}
public void Dispose()
{
if (Retain)
{
//Clear out any retained messages
Publish("");
}
Disposed?.Invoke(this, EventArgs.Empty);
}
public void Dispose()
{
if (Interlocked.Exchange(ref _disposed, 1) != default(int))
{
return;
}
DoDispose();
Disposed?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// When disposed, fire the Disposed event.
/// </summary>
public virtual void Dispose()
{
foreach (IDisposable value in _propertyValues.Values.Where(x => x is IDisposable))
{
value.Dispose();
}
Disposed?.Invoke(this, null);
}
void IDisposable.Dispose()
{
foreach (IChatbot chatbot in this)
{
chatbot.Dispose();
}
Disposed?.Invoke(this, EventArgs.Empty);
}
public void Dispose()
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(NoGcRegion));
}
_disposed = true;
Disposed?.Invoke(this, EventArgs.Empty);
}
private void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
Site?.Container?.Remove(this);
Disposed?.Invoke(this, EventArgs.Empty);
}
public void Dispose()
{
if (!IsDisposed)
{
IsDisposed = true;
Disposed?.Invoke(this, EventArgs.Empty);
monitorConnectionCancellationTokenSource.Cancel();
}
}
protected override void Dispose(bool disposing)
{
_wrapped.Dispose();
Disposed?.Invoke(this, EventArgs.Empty);
_additionalDisposable?.Dispose();
_additionalDisposable = null;
base.Dispose(disposing);
}
protected virtual void Dispose(bool disposing)
{
if (disposing && BaseStream != null)
{
BaseStream.Dispose();
Disposed?.Invoke(this, EventArgs.Empty);
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_engine.Dispose();
}
Disposed?.Invoke(this, EventArgs.Empty);
}
protected override void PostConstruct()
{
base.PostConstruct();
OnActiveStateChange
.Where(v => !v && Valid)
.TakeUntil(Disposed.Where(identity))
.Subscribe(_ => ResetAnimations(), this);
}
public void Dispose()
{
if (bus != null)
{
bus.Dispose();
bus = null;
Disposed?.Invoke(this, EventArgs.Empty);
}
}
public ChildUnitOfWork([NotNull] IUnitOfWork parent)
{
Check.NotNull(parent, nameof(parent));
_parent = parent;
_parent.Failed += (sender, args) => { Failed.InvokeSafely(sender, args); };
_parent.Disposed += (sender, args) => { Disposed.InvokeSafely(sender, args); };
}
/// <summary>
/// Performs texture disposal, deleting the texture.
/// </summary>
private void DisposeTextures()
{
HostTexture.Dispose();
_arrayViewTexture?.Dispose();
_arrayViewTexture = null;
Disposed?.Invoke(this);
}
