C#

public class test<T>
{
   public event EventHandler<TEventArgs<T>> Notification;
}

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

class Test
{
    Dictionary<Type, object> d = new Dictionary<Type,object>();

    public event EventHandler<TEventArgs<int>> MyEvent1
    {
        add
        {
           d.Add(typeof(int), value);
        }

        remove
        {
            d.Remove(typeof(int));
        }
    }

    public event EventHandler<TEventArgs<string>> MyEvent2
    {
        add
        {
            d.Add(typeof(string), value);
        }

        remove
        {
            d.Remove(typeof(string));
        }
    }

    public void OnNotify<T>(T t)
    {
        EventHandler<TEventArgs<T>> del = (EventHandler<TEventArgs<T>> )    d[t.GetType()];
        del(this, new TEventArgs<T>() { Value = t });
    }
}

static void Main()
{
    Test t = new Test();
    t.MyEvent1 += new EventHandler<TEventArgs<int>>((sender, args) => Console.WriteLine(args.Value + 1));
    t.MyEvent2 += new EventHandler<TEventArgs<string>>((sender, args) => Console.WriteLine(args.Value.Trim()));

    t.OnNotify(23);                // Prints 24
    t.OnNotify("Senthil Rocks  "); // Prints Senthil Rocks

public class TEventArgs< T> : EventArgs<br />
		{<br />
			public T Value { get; set; }<br />
		}<br />
<br />
		public static class CoreEventThing<br />
		{<br />
			private static List< Delegate> handlers = new List< Delegate>();<br />
<br />
			public static class TypedEvents< J><br />
			{<br />
				public static event EventHandler< TEventArgs< J>> Event<br />
				{<br />
					add { handlers.Add(value); }<br />
					remove { handlers.Remove(value); }<br />
				}<br />
			}<br />
<br />
<br />
			public static void Raise< T>(T value)<br />
			{<br />
				foreach (var d in handlers)<br />
				{<br />
					if (d is EventHandler< TEventArgs< T>>) <br />
						d.DynamicInvoke(null, new TEventArgs< T> {Value = value});<br />
				}<br />
			}<br />
		}<br />
<br />
		[STAThread]<br />
		public static void Main()<br />
		{<br />
			CoreEventThing.TypedEvents< int>.Event += ((o, e) => Console.WriteLine(e.Value * 5));<br />
			CoreEventThing.TypedEvents< string>.Event += ((o, e) => Console.WriteLine(e.Value));<br />
<br />
			CoreEventThing.Raise(5);<br />
			CoreEventThing.Raise("Mark rocks more!");<br />
		}

DaveyM69 wrote:

any type to be passed in event args

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