C#

public class ApplicationCommand
{
  public char Shortcut { get; set; } // Assuming a single key entry here rather than key combinations
  public Action Command { get; set; }
}

public class CommandMap
{
  private Dictionary<string, ApplicationCommand> applicationCommands = new Dictionary<string, ApplicationCommand>();
  public void AddCommand(string application, ApplicationCommand command)
  {
    Add(application, command);
  }
}

public class MyGameLoop
{
  private CommandMap commandMap = new CommandMap();
  public void Initialize()
  {
    commandMap.AddCommand("Load", new ApplicationCommand('L', ()=> { Debug.WriteLine("Loading"); }));
    commandMap.AddCommand("Save", new ApplicationCommand('S', ()=> { Debug.WriteLine("Saving"); }));
  }
  public void UpdateEntries()
  {
    // Read in from your store here
    ConfigurationStoreReader reader = new ConfigurationStoreReader();
    foreach (Tuple<string, char> element in reader.CommandUpdateMap)
    {
      command[element.Item1] = element.Item2;
    }
  }
  public CommandMap Mapping { get { return command; } }
}

public class Game
{
  private Dictionary<char, Action> actionToPerform = new Dictionary<char, Action>();
  public Game(CommandMap mapping)
  {
    foreach (ApplicationCommand appCommand in mapping.Mapping)
    {
      actionToPerform.Add(appCommand.Shortcut, appCommand.Command);
    }
  }

  public void HandleKeyPress(char keyPress)
  {
    if (actionToPerform.ContainsKey(keyPress))
    {
      actionToPerform[keyPress]();
    } 
  }
}

Pete O'Hanlon wrote:

I've just typed this up in the web editor here

int n;
Stack<int> s;
Stack<n.GetType()> ns; // this will not even compile!

public MainWindow()
{
    InitializeComponent();

    object sender = this;
    WeakReference _sender = new WeakReference(sender);
    EventHandler<EventArgs> handler = (s, e) => this.Title += ".";
    string eventName = "MouseMove";

    Type unboundWEMType = typeof(WeakEventManager<,>);
    Type[] typeArgs = { _sender.Target.GetType(), typeof(EventArgs) };
    Type constructedWEMType = unboundWEMType.MakeGenericType(typeArgs);
    MethodInfo addHandlerMethod = constructedWEMType.GetMethod("AddHandler");
    addHandlerMethod.Invoke(null, new object[] { _sender.Target, eventName, handler });
}

[AttributeUsage(AttributeTargets.Property)]
public sealed class PropertyMediatorAttribute : Attribute
{
    /// <summary>
    /// Message key
    /// </summary>
    public string MessageKey { get; private set; }

    /// <summary>
    /// Default constructor
    /// </summary>
    public PropertyMediatorAttribute()
    {
        MessageKey = null;
    }

    /// <summary>
    /// Constructor that takes a message key
    /// </summary>
    /// <param name="messageKey">Message Key</param>
    public PropertyMediatorAttribute(string messageKey)
    {
        MessageKey = messageKey;
    }
}

public class PropertyMediator
   {
       #region Data
       static readonly PropertyMediator instance = new PropertyMediator();
       static readonly object syncLock = new object();
       private readonly Dictionary<string, List<WeakPropertyDescriptor>> _registeredListners =
           new Dictionary<string, List<WeakPropertyDescriptor>>();
       #endregion

       #region Ctor
       static PropertyMediator()
       {

       }

       private PropertyMediator()
       {

       }
       #endregion

       /// <summary>
       /// Singleton Instance
       /// </summary>
       public static PropertyMediator Instance
       {
           get
           {
               return instance;
           }
       }


       internal class WeakPropertyDescriptor
       {
           public PropertyMediator _MethodOwner;
           public WeakReference _sender;
           public string _PropertyName;
           public string _MessageKey;
           public EventHandler handler;

           public WeakPropertyDescriptor(PropertyMediator MethodOwner, Object sender, string PropertyName, string MessageKey)
           {
               _MethodOwner = MethodOwner;
               _sender = new WeakReference(sender);
               _PropertyName = PropertyName;
               _MessageKey = MessageKey;

               handler = (s, e) => _MethodOwner.NotifyColleaguesOfValueChanged(s, e, _MessageKey, _PropertyName);
               PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(_sender.Target);
               System.ComponentModel.PropertyDescriptor myProperty = properties.Find(PropertyName, false);
               myProperty.AddValueChanged(_sender.Target, handler);

               //Type type = _sender.Target.GetType();

               //// create an instance of that type
               //var instance = Activator.CreateInstance(type);
               //var tt = 5;

            //   WeakEventManager <instance, handler >.AddHandler(_sender.Target, _PropertyName, handler);

           //    ((INotifyPropertyChanged)_sender.Target).PropertyChanged += handler;
           }

       }

       internal void NotifyColleaguesOfValueChanged(object sender, EventArgs e, string key, string PropertyName)
       {

           object message = sender.GetType().GetProperty(PropertyName).GetValue(sender, null);

           List<WeakPropertyDescriptor> wr;
           if (_registeredListners.TryGetValue(key, out wr))
           {
               foreach (WeakPropertyDescriptor item in wr)
               {
                   // Dummy test to check wheter or not to remove items form the list
                   if (item._sender.IsAlive)
                   {
                       PropertyInfo MyProperty = item._sender.Target.GetType().GetProperty(item._PropertyName, BindingFlags.Public | BindingFlags.Instance);

                       // If the property is different then the raised events property, change it
                       if (message != MyProperty.GetValue(item._sender.Target, null))
                       {
                           if (null != MyProperty && MyProperty.CanWrite)
                           {
                               MyProperty.SetValue(item._sender.Target, message, null);
                           }
                       }
                   }
                   else
                   {

                   }


               }
           }

       }

       /// <summary>
       /// http://www.codeproject.com/Articles/217670/The-Third-Way-of-Change-Notification-The-ValueChan
       /// </summary>
       /// <param name="source"></param>
       private void RemoveSourceFromValueChangedEventManager(object source)
       {
           // Remove the source from the ValueChangedEventManager.
           Assembly assembly = Assembly.GetAssembly(typeof(FrameworkElement));
           Type type = assembly.GetType("MS.Internal.Data.ValueChangedEventManager");
           PropertyInfo propertyInfo = type.GetProperty("CurrentManager", BindingFlags.NonPublic | BindingFlags.Static);
           MethodInfo currentManagerGetter = propertyInfo.GetGetMethod(true);
           object manager = currentManagerGetter.Invoke(null, null);
           MethodInfo remove = type.GetMethod("Remove", BindingFlags.NonPublic | BindingFlags.Instance);
           remove.Invoke(manager, new object[] { source });
           // The code above removes the instances of ValueChangedRecord from the
           // WeakEventTable, but they are still rooted by the property descriptors of
           // the source object. We need to clean them out of the property descriptors
           // as well, to allow them to be garbage collected. (Which is necessary
           // because they contain a hard reference to the source, which is what we
           // really want garbage collected.)
           FieldInfo valueChangedHandlersInfo = typeof(PropertyDescriptor).GetField("valueChangedHandlers", BindingFlags.Instance | BindingFlags.NonPublic);
           PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(source);

           foreach (PropertyDescriptor pd in pdc)
           {
               Hashtable changeHandlers = (Hashtable)valueChangedHandlersInfo.GetValue(pd);
               if (changeHandlers != null)
               {
                   changeHandlers.Remove(source);
               }
           }
       }

       private void RegisterProperty(string _MessageKey, object sender, string PropertyName)
       {
           WeakPropertyDescriptor WeakPropertyReferance = new WeakPropertyDescriptor(this, sender, PropertyName, _MessageKey);
           List<WeakPropertyDescriptor> wr;
           if (_registeredListners.TryGetValue(_MessageKey, out wr))
           {

               if (wr != null)
               {
                   wr.Add(WeakPropertyReferance);
               }
           }
           else
           {
               wr = new List<WeakPropertyDescriptor>();
               wr.Add(WeakPropertyReferance);
               _registeredListners[_MessageKey] = wr;

           }

       }

       public void Register(object view)
       {
           // Look at all instance/static properties on this object type.
           foreach (var mi in view.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public))
           {
               //  var test = mi.GetCustomAttributes(typeof(PropertyMediatorAttribute));
               // See if we have a target attribute - if so, register the method as a handler.
               foreach (var att in mi.GetCustomAttributes(typeof(PropertyMediatorAttribute)))
               {
                   var mha = (PropertyMediatorAttribute)att;
                   // Removes all subscribed PropertyDiscriptors from the object
                 //  RemoveSourceFromValueChangedEventManager(view);
                   RegisterProperty(mha.MessageKey, view, mi.Name);
               }
           }
       }

       public void UnRegister(object view)
       {
           // Look at all instance/static properties on this object type.
           foreach (var mi in view.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public))
           {
               //  var test = mi.GetCustomAttributes(typeof(PropertyMediatorAttribute));
               // See if we have a target attribute - if so, register the method as a handler.
               foreach (var att in mi.GetCustomAttributes(typeof(PropertyMediatorAttribute)))
               {
                   var mha = (PropertyMediatorAttribute)att;
                   RemoveSourceFromValueChangedEventManager(view);


               }
           }
       }

   }

public class A : NotifierBase
{
    public A()
    {
        PropertyMediator.Instance.Register(this);

    }


    private string m_Name = "test";
    [PropertyMediatorAttribute("MyProp")]
    public string Name
    {
        get { return m_Name; }
        set
        {
            SetProperty(ref m_Name, value);
        }
    }

    ~A()
    {
        PropertyMediator.Instance.UnRegister(this);
    }

}

/// <summary>
 ///     Implementation of <see cref="INotifyPropertyChanged" />  and Frameworkelement to simplify base drawing classes.
 /// </summary>
 public abstract class NotifierBase : INotifyPropertyChanged
 {
     /// <summary>
     ///     Multicast event for property change notifications.
     /// </summary>
     public event PropertyChangedEventHandler PropertyChanged;

     /// <summary>
     ///     Checks if a property already matches a desired value.  Sets the property and
     ///     notifies listeners only when necessary.
     /// </summary>
     /// <typeparam name="T">Type of the property.</typeparam>
     /// <param name="storage">Reference to a property with both getter and setter.</param>
     /// <param name="value">Desired value for the property.</param>
     /// <param name="propertyName">
     ///     Name of the property used to notify listeners.  This
     ///     value is optional and can be provided automatically when invoked from compilers that
     ///     support CallerMemberName.
     /// </param>
     /// <returns>
     ///     True if the value was changed, false if the existing value matched the
     ///     desired value.
     /// </returns>
     protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
     {

         if (Equals(storage, value))
         {
             return false;
         }

         storage = value;
         this.OnPropertyChanged(propertyName);
         return true;
     }

     /// <summary>
     ///     Notifies listeners that a property value has changed.
     /// </summary>
     /// <param name="propertyName">
     ///     Name of the property used to notify listeners.  This
     ///     value is optional and can be provided automatically when invoked from compilers
     ///     that support <see cref="CallerMemberNameAttribute" />.
     /// </param>
     protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
     {
         this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
 }

Kenneth Haugland wrote:

it does work but it won't allow the connected classes to be garbage collected

internal class WeakPropertyDescriptor
{
    public PropertyMediator _MethodOwner;
    public WeakReference _sender;
    public string _PropertyName;
    public string _MessageKey;
    public EventHandler<EventArgs> handler;
    private Type constructedWEMType;

    public WeakPropertyDescriptor(PropertyMediator MethodOwner, Object sender, string PropertyName, string MessageKey)
    {
        _MethodOwner = MethodOwner;
        _sender = new WeakReference(sender);
        _PropertyName = PropertyName;
        _MessageKey = MessageKey;

        handler = new EventHandler<EventArgs>(WeakPropertyDescriptor_PropertyChanged);

        Type unboundWEMType = typeof(WeakEventManager<,>);
        Type[] typeArgs = { _sender.Target.GetType(), typeof(EventArgs) };
        constructedWEMType = unboundWEMType.MakeGenericType(typeArgs);

        MethodInfo addHandlerMethod = constructedWEMType.GetMethod("AddHandler");
        addHandlerMethod.Invoke(null, new object[] {_sender.Target , "PropertyChanged" , handler});

    }

    private void WeakPropertyDescriptor_PropertyChanged(object sender, EventArgs e)
    {
        PropertyChangedEventArgs arg = (PropertyChangedEventArgs)e;
        if (arg.PropertyName == _PropertyName)
            _MethodOwner.NotifyColleaguesOfValueChanged(_sender.Target, e, _MessageKey, _PropertyName);
    }

    public void RemoveHandler()
    {
        MethodInfo removeHandlerMethod = constructedWEMType.GetMethod("RemoveHandler");
        removeHandlerMethod.Invoke(null, new object[] { _sender.Target, "PropertyChanged", handler });
    }
}