C#

static class Program {
   /// <summary>
   /// The main entry point for the application.
   /// </summary>
   [STAThread]
   static void Main() {
   Application.EnableVisualStyles();
   Application.SetCompatibleTextRenderingDefault(false);

   int testVariable = 23;
   Singleton a = Singleton.Instance;
   Tester b = new Tester();
   a.Notify(testVariable);
   ...
}

public delegate void NotifyDelegate<T>(T instance);

public class Tester {
   public Tester() {
      Singleton.Instance.Subscribe<int>(this.MethodToCall);
   }
   public void MethodToCall(int value) {
      System.Windows.Forms.MessageBox.Show(value.ToString());
   }
}

public class Singleton {
   private class Subscriber {
      private System.Type _type;
      private object _notifyDelegate;
      internal Subscriber(System.Type type, object notifyDelegate) {
         this._type = type;
         this._notifyDelegate = notifyDelegate;
      }
      internal System.Type Type {
         get {
            return this._type;
         }
      }
      internal NotifyDelegate<T> GetNotifyDelegate<t>() {
         return (NotifyDelegate<T> )this._notifyDelegate;
      }
   }
   private static Singleton _instance;
   private System.Collections.Generic.List<Subscriber> _subsribers = new List<Subscriber>();

   private Singleton() {
      _instance = this;
   }

   public void Subscribe<T>(NotifyDelegate<T> delegateToAdd) {
      this._subsribers.Add(new Subscriber(typeof(T), delegateToAdd));
   }
   public void Notify<T>(T instance) {
      foreach (Subscriber item in this._subsribers) {
         if (item.Type.Equals(typeof(T))) {
            item.GetNotifyDelegate<T>()(instance);
         }
      }
   }

   public static Singleton Instance {
      get {
         if (_instance == null) {
            _instance = new Singleton();
         }
         return _instance;
      }
   }
}</t>

Mika Wendelius wrote:

I'm really loosing some hair over here

DaveyM69 wrote:

I've extended it a little so the delegate signature is now (object sender, NotifyEventArgs<t> e)

DaveyM69 wrote:

I might have a look to see if there's some 'magic' way to determine what class called the method

DaveyM69 wrote:

Unsubscribe method at least

DaveyM69 wrote:

I'll pass it by you first as I think this should be a co-author thing with the quality of your help/input

Mika Wendelius wrote:

I'd be very interested if you find a solution

public enum NotifyReasons
{
    Unspecified = 0,
    Created,
    Updated,
    Removed
}
public class NotifyArgs<T>
{
    #region Fields
    private T m_Value;
    private NotifyReasons m_Reason;
    #endregion

    #region Constructors
    public NotifyArgs(T value)
    {
        m_Value = value;
    }
    public NotifyArgs(T value, NotifyReasons reason)
    {
        m_Value = value;
        m_Reason = reason;
    }
    #endregion

    #region Properties
    public T Value
    {
        get { return m_Value; }
    }
    public NotifyReasons Reason
    {
        get { return m_Reason; }
    }
    #endregion
}

private void Notify<T>(object source, NotifyArgs<T> a)
{
    foreach (Subscriber item in m_Subsribers)
        if (item.Type.Equals(typeof(T)))
            item.GetNotifyDelegate<T>()(source, a);
}

private System.Collections.Generic.HashSet< Subscriber > _subsribers = new HashSet<subscriber>();
...
public void Notify< T >(T instance) {
   var subscribers = from item in this._subsribers
                     where item.Type.Equals(typeof(T))
                     select item;

   foreach (Subscriber subscriber in subscribers) {
      subscriber.GetNotifyDelegate< T >()(instance);
   }
}</subscriber>

Mika Wendelius wrote:

Perhaps using email so we could transfer the entire projects