/// <summary>
/// Disposes all components in the chain.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
foreach (var senderComponent in this.Senders)
{
if (this.MidiPort != null)
{
IInitializeByMidiPort init = senderComponent as IInitializeByMidiPort;
if (init != null)
{
init.Uninitialize(this.MidiPort);
}
}
IDisposable disposable = senderComponent as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
this.sender = null;
}
}
}
protected override void Dispose(DisposeObjectKind disposeKind)
{
// I know you're not supposed to throw exceptions in Dispose.
// But the alternative is yanking the unmanaged memory from under the buffers
// that are still being used. That would certainly crash even the most robust
// applications. So view this as an early warning system - as a developer head's up.
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
if (this.usedBuffers.Count > 0)
{
throw new InvalidOperationException("Cannot call Dispose when there are still buffers in use.");
}
}
this.FreeBuffers();
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
this.unusedBuffers.Clear();
this.usedBuffers.Clear();
this.mapBuffers.Clear();
this.buffersReturnedEvent.Close();
}
}
/// <summary>
/// Disposes all components in the chain.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed &&
disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
foreach (var receiverComponent in Receivers)
{
if (MidiPort != null &&
receiverComponent is IInitializeByMidiPort init)
{
init.Uninitialize(MidiPort);
}
if (receiverComponent is IDisposable disposable)
{
disposable.Dispose();
}
}
var disposableChain = RootChain as IDisposable;
// clears RootChain, CurrentChain and Receiver
RootChain = null;
if (disposableChain != null)
{
disposableChain.Dispose();
}
}
}
/// <summary>
/// Closes the Midi Port (if needed) and disposes the instance.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
/// <remarks>
/// If <paramref name="disposeKind"/> is set to Managed the <see cref="P:BufferManager"/> is also disposed.
/// </remarks>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed)
{
try
{
if (Status != MidiPortStatus.Closed)
{
Close();
}
}
catch (MidiException e)
{
// do nothing
Debug.WriteLine(e);
}
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
_instanceHandle.Free();
}
Status = MidiPortStatus.None;
}
}
/// <summary>
/// Disposes the object instance and its internal timer.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed)
{
_timer.Dispose();
}
}
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
_inPort.Dispose();
}
}
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources &&
Context != null)
{
Detach().Dispose();
}
}
/// <inheritdocs/>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed &&
disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
StreamWriter.Dispose();
}
}
/// <inheritdocs/>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources &&
BaseStream != null)
{
BaseStream.Dispose();
}
}
/// <summary>
/// Called to dispose the instance.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose of.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
this.catalog.Dispose();
}
base.Dispose();
}
/// <summary>
/// Disposes of the internal disposables.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed &&
disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
Clear();
_signal.Close();
}
}
/// <inheritdocs/>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
this.BaseStream.Dispose();
}
}
}
/// <summary>
/// Disposes this instance.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
base.Dispose(disposeKind);
if (!IsDisposed &&
disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources &&
_bufferManager != null)
{
_bufferManager.Dispose();
}
}
/// <inheritdocs/>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
ChunkFile.Dispose();
if (_services != null)
{
_services.Dispose();
}
}
}
/// <inheritdocs/>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
this.ChunkFile.Dispose();
if (this.compositionContainer != null)
{
this.compositionContainer.Dispose();
}
}
}
/// <summary>
/// Disposes the object instance.
/// </summary>
/// <param name="disposeKind">The type if resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed && _timerId != 0)
{
var result = NativeMethods.timeKillEvent(_timerId);
_timerId = 0;
if (result != NativeMethods.TIMERR_NOERROR)
{
Console.WriteLine(Properties.Resources.Timer_FailedToKillTimer);
}
}
}
/// <summary>
/// Disposes the object by checking all user data objects and calling
/// <see cref="IDisposable.Dispose"/> if they implement it.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
foreach (var regList in _registrations.Values)
{
foreach (var reg in regList)
{
if (reg.UserData is IDisposable disposable)
{
disposable.Dispose();
}
}
}
}
/// <summary>
/// Disposes the object by checking all user data objects and calling
/// <see cref="IDisposable.Dispose"/> if they implement it.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
foreach (var regList in this.registrations.Values)
{
foreach (var reg in regList)
{
var disposable = reg.UserData as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
}
/// <summary>
/// Disposes this instance.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
/// <remarks>Closes the Midi In Port. If <paramref name="disposeKind"/> is Managed
/// the <see cref="P:BufferManager"/> and the <see cref="Successor"/> and the
/// <see cref="NextErrorReceiver"/> are set to null.</remarks>
protected override void Dispose(DisposeObjectKind disposeKind)
{
base.Dispose(disposeKind);
if (!IsDisposed &&
disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
// we dispose the buffer manager last.
// base.Dispose can call Close and that needs a working buffer manager.
if (_bufferManager != null)
{
_bufferManager.Dispose();
}
_receiver = null;
_errorReceiver = null;
_portEventReceiver = null;
}
}
/// <inheritdocs/>
protected override void Dispose(DisposeObjectKind disposeKind)
{
try
{
if (!IsDisposed)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
if (this.bufferManager != null)
{
this.bufferManager.Dispose();
}
}
}
}
finally
{
base.Dispose(disposeKind);
}
}
/// <summary>
/// Disposes all components in the chain.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed &&
disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
foreach (var senderComponent in Senders)
{
if (MidiPort != null &&
senderComponent is IInitializeByMidiPort init)
{
init.Uninitialize(MidiPort);
}
if (senderComponent is IDisposable disposable)
{
disposable.Dispose();
}
}
_sender = null;
}
}
/// <summary>
/// Disposes all components in the chain.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
if (!IsDisposed)
{
if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
{
foreach (var receiverComponent in this.Receivers)
{
if (this.MidiPort != null)
{
IInitializeByMidiPort init = receiverComponent as IInitializeByMidiPort;
if (init != null)
{
init.Uninitialize(this.MidiPort);
}
}
IDisposable disposable = receiverComponent as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
IDisposable disposableChain = this.RootChain as IDisposable;
// clears RootChain, CurrentChain and Receiver
this.RootChain = null;
if (disposableChain != null)
{
disposableChain.Dispose();
}
}
}
}
protected override void Dispose(DisposeObjectKind disposeKind)
{
Close();
this.outPort.Dispose();
}
protected override void Dispose(DisposeObjectKind disposeKind)
{
this.context.Dispose();
}
/// <summary>
/// Called when disposing the object instance.
/// </summary>
/// <param name="disposeKind">The type of resources to dispose.</param>
protected override void Dispose(DisposeObjectKind disposeKind)
{
// no op
}
/// <summary>
/// Called either from <see cref="M:Dispose"/> or the Finalizer (not in this base class)
/// to dispose of this instance.
/// </summary>
/// <param name="disposeKind">Indicates what type of resources to dispose of.</param>
/// <remarks>Derived classes override to Dispose their members.</remarks>
/// <example>
/// <code>
/// if (!IsDisposed)
/// {
/// if (disposeKind == DisposeObjectKind.ManagedAndUnmanagedResources)
/// {
/// // dispose managed resources
/// }
/// // dispose unmanaged resources
/// }
/// </code>
/// </example>
protected abstract void Dispose(DisposeObjectKind disposeKind);
protected override void Dispose(DisposeObjectKind disposeKind)
{
_inPort.Dispose();
}
protected override void Dispose(DisposeObjectKind disposeKind)
{
this.SysExReceiver.Dispose();
this.SysExSender.Dispose();
}
