C#

#ifdef __cplusplus
extern "C" {
#endif
__declspec(dllexport) LPVOID /* (void*) */ CreateGOClass();
__declspec(dllexport) void DestroyGOClass(LPVOID lpClass);
#ifdef __cplusplus
}
#endif

[DllImport("mylib.dll")]
private static extern IntPtr CreateGOClass();
[DllImport("mylib.dll")]
private static extern void DestroyGOClass(IntPtr inst);
[DllImport("mylib.dll", CallingConvention=CallingConvention.ThisCall)]
private static extern void SomeMethod(IntPtr inst, int param1, int param2);

public sealed class GraphicsOptions : IDisposable
{
  private static GraphicsOptions instance;
  private IntPtr inst;
  private GraphicsOptions()
  {
    inst = CreateGOClass();
  }
  private static GraphicsOptions Instance
  {
    get
    {
      if (instance == null)
        lock (typeof(GraphicsOptions))
          if (instance == null)
            instance = new GraphicsOptions();
      return instance;
    }
  }
  public static void SomeMethod(int param1, int param2)
  {
    SomeMethod(Instance.inst, param1, param2);
  }
  void IDisposable.Dispose()
  {
    DestroyGOClass(inst);
    GC.SuppressFinalize(this);
  }
  [DllImport("mylib.dll")]
  private static extern IntPtr CreateGOClass();
  [DllImport("mylib.dll")]
  private static extern void DestroyGOClass(IntPtr inst);
  [DllImport("mylib.dll", CallingConvention=CallingConvention.ThisCall)]
  private static extern void SomeMethod(IntPtr inst, int param1, int param2);
}

GraphicsOptions.SomeMethod(1, 2);

//  C#, AS-IS, may need tweaking, minimal comments
 
using   System;
using   System.Collections;
using   System.Diagnostics;
using   System.Threading;
 
public delegate void   ProcessStartedEventHandler(object sender, Process proc);
 
public delegate void   ProcessExitedEventHandler(object sender, Process proc);
 
public class   ProcessWatcher
{
   #region   Constants
   //   scan at XXXXms intervals from last scan
   private const int  SCAN_INTERVAL = 250;
   #endregion   Constants
 
   #region   Instance Fields
   private Mutex   _myLock = new Mutex(false);
   private Hashtable   _procList = new Hashtable();
   private Timer   _scanTimer = null;
   #endregion   Instance Fields
 
   #region   Construction / Destruction
   public   ProcessWatcher()   {   }
 
   ~ ProcessWatcher()
   {
      Stop();
   }
   #endregion   Construction / Destruction
 
   #region   Methods
   public void   Start()
   {
      _myLock.WaitOne();
 
      //   sanity
      if (_scanTimer != null)
      {
         _myLock.ReleaseMutex();
         
         return;
      }
 
      _procList.Clear();
 
     //  kick off the scan
      _scanTimer = new Timer(new TimerCallback(_Scan), null,
         SCAN_INTERVAL, Timeout.Infinite);
 
      _myLock.ReleaseMutex();
   }
 
   public void   Stop()
   {
      _myLock.WaitOne();   //  wait for access
 
      //   sanity
      if (null == _scanTimer)
      {
         _scanMutex.ReleaseMutex();
         
         return;
      }
 
      _scanTimer.Dispose();
      _scanTimer = null;
 
      _procList.Clear();
 
      _myLock.ReleaseMutex();
   }
   #endregion   Methods
 
   #region   Implementation
   private void   _Scan(object unused)
   {
      _myLock.WaitOne();   //  wait for access
 
      //  prevent firing while working
      _scanTimer.Change(Timeout.Infinite, Timeout.Infinite);

      //  copy list of event subscribers AT THE TIME OF THIS SCAN
      //  the current subscribers will be copied by the assignment operator
      ProcessStartedEventHandler  startListeners = ProcessStarted;
      ProcessExitedEventHandler   exitListeners = ProcessExited;
 
      //   first we'll scan for those processes which ended
      ArrayList  list = new ArrayList();
      Process   cur = null;
 
      foreach (Process proc in _procList)
      {
         if (!proc.HasExited)  continue;
 
         list.Add(proc.Id);
      }
 
      //  fire off exit notifications and remove
      foreach (int id in list)
      {
         if (exitListeners != null)
            exitListeners(this, (Process)_procList[id]));
 
         _procList.Remove(id);
      }
      
      list.Clear();
 
      //   get current processes
      Process[]  running = Process.GetProcesses();
 
      foreach (Process proc in running)
      {
         if (_procList.Contains(proc.Id))   continue;
 
         list.Add(proc);   //  got a new one!
      }
 
      //  fire off notifications and add
      foreach (Process proc in list)
      {
         _procList.Add(proc.Id, proc);
 
         if (startListeners != null)
            startListeners(this, proc); 
      }
 
      //  setup next call and release mutex
      _scanTimer.Change(SCAN_INTERVAL, Timeout.Infinite);
      _myLock.ReleaseMutex();
   }
   #endregion   Implementation
 
   #region   Events
   public event ProcessStartedEventHandler   ProcessStarted;
   public event ProcessExitedEventHandler   ProcessExited;
   #endregion   Events
}

public sealed class MySingleton
{
  private static MySingleton instance;
  private int i;
  private MySingleton()
  {
    i = 1;
  }
  public static MySingleton Instance // Often private, though
  {
    get
    {
      if (instance == null)
        lock (typeof(MySingleton))
          if (instance == null)
            instance = new MySingleton();
      return instance;
    }
  }
  public static int SomeMethod()
  {
    return Instance.i; // Use Instance, not instance to make sure it's init'd.
  }
}