C#

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 ?

private void OpenFix_Click(object sender, System.EventArgs e)
{
   Form2 fix = new Form2();
   fix.Open();
}

public ProgressBar pb;

private void openChild_Click(object sender, System.EventArgs e)
{
   ChildForm cf = new ChildForm();
   cf.pf = this;
   cf.open();
}

public ParentForm pf;

private void runProgressBar_Click(object sender, System.EventArgs e)
{
  for(int i = 0;i<100;i++)
    {
       pf.pb.Value++;
    }
}

----node1
       node1_child1
       node1_child2
                node1_child2_child1
                node1_child2_child2
       node1_child3
                node1_child3_child1
                node1_child3_child2
                node1_child3_child3

nodeList.Add(treeNode);
if (treeNode.Nodes.Count > 0) {
  treeNode = GetChildNodes(treeNode.Nodes[treeNode.Nodes.Count - 1]);
}
return treeNode;

nodeList.Add(treeNode);
if (treeNode.Nodes.Count > 0) {
   GetChildNodes(treeNode.Nodes[treeNode.Nodes.Count - 1]);
}
return nodeList;