A sound player for .NET 2.0

// A sound player for .NET 2.0 (requires a C# 3.0 compiler)
// Written by Allon Guralnek. No Rights Reserved. You may use this code anyway you like,
// even without attribution.

// Combined: QueuedSamplesPlayer.cs + MessageNotifier.cs + EventArgs.cs

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

class QueuedSamplesPlayer<T> : IDisposable where T : struct
{
    private Queue<T> SampleQueue { get; set; }
    private List<T> LoadedSamples { get; set; }
    public bool IsPlaying { get; private set; }
    public MessageNotifier Notifier { get; private set; }

    public event EventHandler QueueEmpty;

    public QueuedSamplesPlayer()
    {
        SampleQueue = new Queue<T>();
        LoadedSamples = new List<T>();
        Notifier = new MessageNotifier(0x3B9);
        Notifier.MessageRecieved += Notifier_MessageRecieved;
    }

    public void AddSample(T key, string file)
    {
        SendCommand("open \"" + file + "\" type mpegvideo alias Sample" + key + " wait", false);
        SendCommand("set Sample" + key + " time format milliseconds wait", false);
        SendCommand("seek Sample" + key + " to 50 wait", false);
        LoadedSamples.Add(key);
    }

    public void Play(params T[] keys)
    {
        IsPlaying = true;

        foreach (T key in keys)
        {
            SendCommand("play Sample" + key + " wait", false);
            SendCommand("seek Sample" + key + " to 50", false);
        }

        IsPlaying = false;
    }
    public void PlayAsync(params T[] keys)
    {
        foreach (T key in keys)
            SampleQueue.Enqueue(key);

        if (!IsPlaying)
            PlayNext();
    }
    public void Stop()
    {
        SampleQueue.Clear();
    }
    private void PlayNext()
    {
        if (SampleQueue.Count > 0)
        {
            IsPlaying = true;
            T key = SampleQueue.Dequeue();
            SendCommand("seek Sample" + key + " to 50 wait", false);
            SendCommand("play Sample" + key + " notify", true);
        }
        else
        {
            IsPlaying = false;
            OnQueueEmpty();
        }
    }
    private void Notifier_MessageRecieved(object sender, EventArgs<Message> e)
    {
        PlayNext();
    }

    private void SendCommand(string command, bool notify)
    {
        int retVal;
        if ((retVal = NativeMethods.mciSendString(command, null, 0, notify ? Notifier.Handle : IntPtr.Zero)) != 0)
        {
            var errorMessage = new StringBuilder(200);
            NativeMethods.mciGetErrorString(retVal, errorMessage, errorMessage.Capacity);
            throw new Exception("MCI Error " + retVal + ": " + errorMessage);
        }
    }
    private void OnQueueEmpty()
    {
        if (QueueEmpty != null)
            QueueEmpty(this, EventArgs.Empty);
    }

    public void Dispose()
    {
        if (Notifier != null)
            Notifier.Dispose();

        if (LoadedSamples != null)
        {
            foreach (var sample in LoadedSamples)
            {
                SendCommand("stop Sample" + sample + " wait", false);
                SendCommand("close Sample" + sample + " wait", false);
            }
        }
    }
}

internal static class NativeMethods
{
    [DllImport("winmm.dll")]
    public static extern int mciSendString(string command, StringBuilder buffer, int bufferSize, IntPtr hwndCallback);
    [DllImport("winmm.dll")]
    public static extern int mciGetErrorString(int errorCode, StringBuilder errorText, int errorTextSize);
}



public class MessageNotifier : IDisposable
{
    public int Message { get; private set; }
    public IntPtr Handle
    {
        get
        {
            return MessageNotifyingForm.Instance.Handle;
        }
    }

    public event EventHandler<EventArgs<Message>> MessageRecieved;

    public MessageNotifier(int message)
    {
        Message = message;
        MessageNotifyingForm.Instance.RegisterMessageNotifiction(Message, MessageNotifingForm_MessageRecieved);
    }

    private void MessageNotifingForm_MessageRecieved(object sender, EventArgs<Message> e)
    {
        if (MessageRecieved != null)
            MessageRecieved(this, e);
    }

    public void Dispose()
    {
        MessageNotifyingForm.Instance.UnregisterMessageNotifiction(Message, MessageNotifingForm_MessageRecieved);
    }


    private class MessageNotifyingForm : Form
    {
        private Dictionary<int, List<EventHandler<EventArgs<Message>>>> Listeners { get; set; }

        public static MessageNotifyingForm Instance
        {
            get
            {
                return g_Instance ?? (g_Instance = new MessageNotifyingForm());
            }
            private set
            {
                g_Instance = value;
            }
        }

        private MessageNotifyingForm()
        {
            Listeners = new Dictionary<int, List<EventHandler<EventArgs<Message>>>>();
        }
        public void RegisterMessageNotifiction(int message, EventHandler<EventArgs<Message>> eventHandler)
        {
            if (!Listeners.ContainsKey(message))
                Listeners[message] = new List<EventHandler<EventArgs<Message>>>();

            Listeners[message].Add(eventHandler);
        }
        public void UnregisterMessageNotifiction(int message, EventHandler<EventArgs<Message>> eventHandler)
        {
            var listenerList = Listeners[message];
            listenerList.Remove(eventHandler);
            if (listenerList.Count == 0)
                Listeners.Remove(message);

            if (listenerList.Count == 0)
            {
                g_Instance = null;
                Dispose();
            }
        }
        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            if (Listeners.ContainsKey(m.Msg))
            {
                foreach (var listener in Listeners[m.Msg])
                {
                    listener(this, new EventArgs<Message>(m));
                }
            }
        }

        private static MessageNotifyingForm g_Instance;
    }
}

public class EventArgs<T> : EventArgs
{
    public T EventData { get; set; }

    public EventArgs(T eventData)
    {
        EventData = eventData;
    }
}