using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

public class Program

{

    public static void Main()

    {

        var messenger = new Messenger();

        var receiver = new Receiver(messenger);

        var sender = new Sender(messenger);

    }

}

​

public class Receiver

    {

        public Receiver(Messenger messenger)

        {

            messenger.Register<string>(x =>

            {

                Console.WriteLine(x);

            });

​

            messenger.Register<string, string>(x =>

                {

                    if (x == "hello")

                    {

                        return "world";

                    }

                    return "who are you?";

                });

​

            messenger.Register<string, string>(x =>

            {

                if (x == "world")

                {

                    return "hello";

                }

                return "what are you?";

            });

        }

    }

    public class Sender

    {

        public Sender(Messenger messenger)

        {

            messenger.Send<string>("Hello world!");

            Console.WriteLine("");

​

            foreach (string result in messenger.Request<string, string>("hello"))

            {

                Console.WriteLine(result);

            }

            Console.WriteLine("");

            foreach (string result in messenger.Request<string, string>("world"))

            {

                Console.WriteLine(result);

            }

        }

    }

​

public class Messenger

    {

        /// <summary>

        /// The actions

        /// </summary>

        private Dictionary<Type, Delegate> actions = new Dictionary<Type, Delegate>();

        /// <summary>

        /// The functions

        /// </summary>

        private Dictionary<Type, Collection<Delegate>> functions = new Dictionary<Type, Collection<Delegate>>();

        /// <summary>

        /// Register a function for a request message.

        /// </summary>

        /// <typeparam name="T"> Type of message to receive. </typeparam>

        /// <typeparam name="R"> Type of the r. </typeparam>

        /// <param name="request"> The function that fills the request. </param>

        public void Register<T, R>(Func<T, R> request)

        {

            if (request == null)

            {

                throw new ArgumentNullException("request");

            }

            if (functions.ContainsKey(typeof(T)))

            {

                functions[typeof(T)].Add(request);

            }

            else

            {

                functions.Add(typeof(T), new Collection<Delegate>()

                {

                    request

                });

            }

        }

        /// <summary>

        /// Register an action for a message.

        /// </summary>

        /// <typeparam name="T"> Type of message to receive. </typeparam>

        /// <param name="action"> The action that happens when the message is received. </param>

        public void Register<T>(Action<T> action)

        {

            if (action == null)

            {

                throw new ArgumentNullException("action");

            }

            if (actions.ContainsKey(typeof(T)))

            {

                actions[typeof(T)] = Delegate.Combine(actions[typeof(T)], action);

            }

            else

            {

                actions.Add(typeof(T), action);

            }

        }

        /// <summary>

        /// Send a request.

        /// </summary>

        /// <typeparam name="T"> The type of the parameter of the request. </typeparam>

        /// <typeparam name="R"> The return type of the request. </typeparam>

        /// <param name="parameter"> The parameter. </param>

        /// <returns> The result of the request. </returns>

        public IEnumerable<R> Request<T, R>(T parameter)

        {

            if (functions.ContainsKey(typeof(T)))

            {

                var applicableFunctions = functions[typeof(T)].OfType<Func<T, R>>();

                foreach (var function in applicableFunctions)

                {

                    yield return function(parameter);

                }

            }

        }

        /// <summary>

        /// Sends the specified message.

        /// </summary>

        /// <typeparam name="T"> The type of message. </typeparam>

        /// <param name="message"> The message. </param>

        public void Send<T>(T message)

        {

            if (actions.ContainsKey(typeof(T)))

            {

                ((Action<T>)actions[typeof(T)])(message);

            }

        }

        /// <summary>

        /// Unregister a request.

        /// </summary>

        /// <typeparam name="T"> The type of request to unregister. </typeparam>

        /// <typeparam name="R"> The return type of the request. </typeparam>

        /// <param name="request"> The request to unregister. </param>

        public void Unregister<T, R>(Func<T, R> request)

        {

            if (functions.ContainsKey(typeof(T)) && functions[typeof(T)].Contains(request))

            {

                functions[typeof(T)].Remove(request);

            }

        }

        /// <summary>

        /// Unregister an action.

        /// </summary>

        /// <typeparam name="T"> The type of message. </typeparam>

        /// <param name="action"> The action to unregister. </param>

        public void Unregister<T>(Action<T> action)

        {

            if (actions.ContainsKey(typeof(T)))

            {

                actions[typeof(T)] = (Action<T>)Delegate.Remove(actions[typeof(T)], action);

            }

        }

    }