C#

Mika Wendelius wrote:

can it be any type, even a class that the singleton isn't aware of?

Mika Wendelius wrote:

If the type is known to the singleton, wouldn't this lead to hardcoding the possible types... this is what you're trying to prevent.

Mika Wendelius wrote:

wouldn't it be sufficient to carry the type info in custom eventargs without generics

// TEventArgs.cs
using System;
public class TEventArgs<T> : EventArgs
{
    private T m_Value;
    public TEventArgs(T value)
    {
        m_Value = value;
    }
    public T Value
    {
        get { return m_Value; }
    }
}

// Notifier.cs
using System;
public class Notifier<T>
{
    public event EventHandler<TEventArgs<T>> Notification;
    public void Notify(T value)
    {
        OnNotify(new TEventArgs<T>(value));
    }
    protected virtual void OnNotify(TEventArgs<T> e)
    {
        EventHandler<TEventArgs<T>> eh = Notification;
        if (eh != null)
            eh(this, e);
    }
}

// Program.cs
using System;
using System.Windows.Forms;
static class Program
{
    [STAThread]
    static void Main()
    {
        Application.Run(new Form1());
    }
    private static Notifier<int> intNotifier = new Notifier<int>();
    private static Notifier<string> stringNotifier = new Notifier<string>();
    public static Notifier<int> IntNotifier
    {
        get { return intNotifier; }
    }
    public static Notifier<string> StringNotifier
    {
        get { return stringNotifier; }
    }
}

// Form1.cs
using System;
using System.Windows.Forms;
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        Form2 frm2 = new Form2();
        Program.IntNotifier.Notification += new EventHandler<TEventArgs<int>>(IntNotifier_Notification);
        Program.StringNotifier.Notification += new EventHandler<TEventArgs<string>>(StringNotifier_Notification);
        Program.IntNotifier.Notify(5);
        Program.StringNotifier.Notify("This rocks!");
    }
    void IntNotifier_Notification(object sender, TEventArgs<int> e)
    {
        Console.WriteLine(e.Value);
    }
    void StringNotifier_Notification(object sender, TEventArgs<string> e)
    {
        Console.WriteLine(e.Value);
    }
}

// Form2.cs
using System;
using System.Windows.Forms;
public partial class Form2 : Form
{
    public Form2()
    {
        InitializeComponent();
        Program.IntNotifier.Notification += new EventHandler<TEventArgs<int>>(IntNotifier_Notification);
    }
    void IntNotifier_Notification(object sender, TEventArgs<int> e)
    {
        Program.StringNotifier.Notify("Got the integer " + e.Value);
    }
}

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