C#

Gideon Engelberth wrote:

it is entirely possible that they could clean up the Ports first

public class Port : IDisposable
{

   ~Port()
   {
      Dispose(false);
   }

   public void IDisposable.Dispose()
   {
        Dispose(true);
        GC.SupressFinalize(this);
   }
   
   private bool alreadyDisposed;
   protected void Dispose(bool disposing)
   {
      if (!alreadyDisposed)
      {
         if (disposing)
         {
            //clean up managed
         }

         //always clean up unmanaged
         
         alreadyDisposed = true;
      }
   }

   public void Close()
   {
      Dispose();
   }

   //other class code here
}

Luc Pattyn wrote:

one should provide a Dispose(bool) override.

Luc Pattyn wrote:

GC does not finalize anything when an application exits; it does when things got collected, which only happens when a new need for memory

Luc Pattyn wrote:

The one Manager object you create sits in a static member of class Manager, so it never dies.

Luc Pattyn wrote:

Application.Exit

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace MIDI.Test
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            Load += new EventHandler(Form1_Load);
            FormClosing += new FormClosingEventHandler(Form1_FormClosing);
        }

        void Form1_Load(object sender, EventArgs e)
        {
            foreach (Port port in Manager.Ports)
            {
                port.Closed += new EventHandler(port_Closed);
                port.Opened += new EventHandler(port_Opened);
                port.Open();
            }
        }

        void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            /* Commenting out the next line will rely on the manager finalizer's call to CloseAll.
             * Doing this seems (confusingly) to be reliable! */
            Manager.CloseAll();
        }

        void port_Closed(object sender, EventArgs e)
        {
            Port port = sender as Port;
            if(port !=null) 
                Console.WriteLine("{0}[{1}] closed", port.Type, port.ID);
        }

        void port_Opened(object sender, EventArgs e)
        {
            Port port = sender as Port;
            if (port != null)
                Console.WriteLine("{0}[{1}] opened", port.Type, port.ID);
        }
    }

    public class Manager
    {
        private static List<Input> inputs;
        private static List<Output> outputs;
        private static List<Port> ports;

        private static Manager manager = new Manager();

        static Manager()
        {
            Initialize();
        }
        private Manager()
        { }

        ~Manager()
        {
            CloseAll();
        }

        public static IList<Input> Inputs
        {
            get { return inputs.AsReadOnly(); }
        }
        public static IList<Output> Outputs
        {
            get { return outputs.AsReadOnly(); }
        }
        public static IList<Port> Ports
        {
            get { return ports.AsReadOnly(); }
        }

        public static void CloseAll()
        {
            foreach (Port port in ports)
                port.Close();
        }

        private static void Initialize()
        {
            int inputCount = Interop.midiInGetNumDevs();
            int outputCount = Interop.midiOutGetNumDevs();

            ports = new List<Port>(inputCount + outputCount);

            inputs = new List<Input>(inputCount);
            if (inputCount > 0)
                for (int i = 0; i < inputCount; i++)
                {
                    inputs.Add(new Input(i));
                    ports.Add(inputs[i]);
                }

            outputs = new List<Output>(outputCount);
            if (outputCount > 0)
                for (int i = 0; i < outputCount; i++)
                {
                    outputs.Add(new Output(i));
                    ports.Add(outputs[i]);
                }
        }
    }

    public class Input : Port
    {
        internal Input(int id)
            : base(PortType.Input, id)
        { }

        public override void Close()
        {
            if (handle != IntPtr.Zero)
            {
                Interop.midiInClose(handle);
                handle = IntPtr.Zero;
            }
        }

        public override void Open()
        {
            if (handle == IntPtr.Zero)
                Interop.midiInOpen(
                    out handle, id, callback, id, Interop.CALLBACK_FUNCTION);
        }
    }

    public class Output : Port
    {
        internal Output(int id)
            : base(PortType.Output, id)
        { }

        public override void Close()
        {
            if (handle != IntPtr.Zero)
            {
                Interop.midiOutClose(handle);
                handle = IntPtr.Zero;
            }
        }

        public override void Open()
        {
            if (handle == IntPtr.Zero)
                Interop.midiOutOpen(
                    out handle, id, callback, id, Interop.CALLBACK_FUNCTION);
        }
    }

    public abstract class Port
    {
        public event EventHandler Opened;
        public event EventHandler Closed;

        internal Interop.MidiProc callback;
        protected IntPtr handle;
        protected int id;

        internal Port(PortType type, int id)
        {
            callback = OnCallback;
            handle = IntPtr.Zero;
            this.id = id;
            Type = type;
        }

        public int ID
        {
            get { return id; }
        }

        public PortType Type
        {
            get;
            private set;
        }

        public abstract void Close();

        protected virtual void OnCallback(IntPtr hMidi, int wMsg, int dwInstance, int dwParam1, int dwParam2)
        {
            switch (wMsg)
            {
                case Interop.MIM_CLOSE:
                case Interop.MOM_CLOSE:
                    OnClosed(EventArgs.Empty);
                    break;
                case Interop.MIM_OPEN:
                case Interop.MOM_OPEN:
                    OnOpened(EventArgs.Empty);
                    break;
            }
        }

        protected virtual void OnClosed(EventArgs e)
        {
            EventHandler eh = Closed;
            if (eh != null)
                eh(this, e);
        }

        protected virtual void OnOpened(EventArgs e)
        {
            EventHandler eh = Opened;
            if (eh != null)
                eh(this, e);
        }

        public abstract void Open();
    }

    public enum PortType
    {
        Input = 0,
        Output = 1
    }

    internal static class Interop
    {
        public const int CALLBACK_FUNCTION = 0x00030000;
        public const int MIM_OPEN = 0x3C1;
        public const int MIM_CLOSE = 0x3C2;
        public const int MOM_OPEN = 0x3C7;
        public const int MOM_CLOSE = 0x3C8;

        public delegate void MidiProc(
            IntPtr hMidi,
            int wMsg,
            int dwInstance,
            int dwParam1,
            int dwParam2);

        [DllImport("winmm.dll")]
        public static extern int midiInClose(
            IntPtr hMidiIn
            );

        [DllImport("winmm.dll")]
        public static extern int midiInGetNumDevs();

        [DllImport("winmm.dll")]
        public static extern int midiInOpen(
            out IntPtr lphMidiIn,
            int uDeviceID,
            MidiProc dwCallback,
            int dwCallbackInstance,
            int dwFlags
            );

        [DllImport("winmm.dll")]
        public static extern int midiOutClose(
            IntPtr hmo
            );

        [DllImport("winmm.dll")]
        public static extern int midiOutGetNumDevs();

        [DllImport("winmm.dll")]
        public static extern int midiOutOpen(
            out IntPtr lphmo,
            int uDeviceID,
            MidiProc dwCallback,
            int dwCallbackInstance,
            int dwFlags
            );
    }
}

Luc Pattyn wrote:

finalizers aren't 100% trustworthly ... Task Manager

using System;
using System.Runtime.InteropServices;

public class Output
{
    private const int CALLBACK_FUNCTION = 0x00030000;
    private const int MOM_CLOSE = 0x3C8;
    private const int MOM_OPEN = 0x3C7;

    private delegate void MidiProc(
        IntPtr hMidi,
        int wMsg,
        int dwInstance,
        int dwParam1,
        int dwParam2);

    [DllImport("winmm.dll")]
    private static extern int midiOutClose(
        IntPtr hmo
        );

    [DllImport("winmm.dll")]
    private static extern int midiOutOpen(
        out IntPtr lphmo,
        int uDeviceID,
        MidiProc dwCallback,
        int dwCallbackInstance,
        int dwFlags
        );

    private MidiProc callback;
    private IntPtr handle;
    private int id;

    public Output(int id)
    {
        callback = OnCallback;
        handle = IntPtr.Zero;
        this.id = id;
    }
    ~Output() // Unreliable as no way to determine when this will be called
    {
        Close();
    } /* MIDI sub sytem will now use callback to send MIM_CLOSE if
       * Output was open but callback may have been collected */

    public void Close()
    {
        if (handle != IntPtr.Zero)
        {
            midiOutClose(handle);
            handle = IntPtr.Zero;
        }
    }
    private void OnCallback(
        IntPtr hMidi, int wMsg, int dwInstance, int dwParam1, int dwParam2)
    {
        // ...
    }
    public void Open()
    {
        if (handle == IntPtr.Zero)
            midiOutOpen(
                out handle, id, callback, id, CALLBACK_FUNCTION);
    }
}

using System;

namespace MIDI.NET.Ports
{
    /// <summary>
    /// Represents a MIDI port.
    /// </summary>
    public abstract class Port : IDisposable
    {
        bool disposed;

        ~Port()
        {
            Dispose(false);
        }

        public virtual void Close()
        {
            if (disposed)
                throw new ObjectDisposedException(
                    ToString(),
                    "This port has been disposed. If you wish to reuse it please use the ReCreate method.");
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    // Managed clean up only
                }
                Close();
                disposed = true;
            }
        }

        public void Recreate()
        {
            if (disposed)
            {
                GC.ReRegisterForFinalize(this);
                disposed = false;
            }
        }
    }
}

Rick van Woudenberg wrote:

Weird huh ?