source: branches/ParameterBinding/HeuristicLab.Core/3.3/ItemBinding.cs @ 4787

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Common;
using System.Reflection;
using System.Reflection.Emit;

namespace HeuristicLab.Core {
  [StorableClass]
  public sealed class ItemBinding : IItemBinding {
    private static readonly BindingFlags Flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
    [Storable]
    private IDeepCloneable target;
    [Storable]
    private string targetPath;
    [Storable]
    private IDeepCloneable source;
    [Storable]
    private string sourcePath;
    [Storable]
    private bool bound;

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

    [StorableConstructor]
    private ItemBinding(bool deserializing) { }
    private ItemBinding(ItemBinding original, Cloner cloner) {
      this.target = cloner.Clone(original.target);
      this.targetPath = original.targetPath;
      this.source = cloner.Clone(original.source);
      this.sourcePath = original.sourcePath;
      if (original.bound) Bind();
    }
    public ItemBinding(IDeepCloneable target, string targetPath, IDeepCloneable source, string sourcePath) {
      this.target = target;
      this.targetPath = targetPath;
      this.source = source;
      this.sourcePath = sourcePath;
      this.bound = false;
    }

    public IDeepCloneable Clone(Cloner cloner) {
      return new ItemBinding(this, cloner);
    }

    public object Clone() {
      return Clone(new Cloner());
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (bound) RegisterEventHandlers();
    }

    public void Bind() {
      RegisterEventHandlers();
      bound = true;
      ExecuteBinding(null);
    }

    public void Unbind() {
      DeregisterEventHandlers();
      bound = false;
    }

    private void RegisterEventHandlers() {
      string[] properties = sourcePath.Split('.');
      object current = source;
      foreach (string property in properties) {
        TryHookToChangedEvent(current, property + "Changed");
        MethodInfo mInfo = current.GetType().GetProperty(property, Flags).GetGetMethod(true);
        object next = mInfo.Invoke(current, null);
        if (next == null) return;
        current = next;
      }
    }

    private void DeregisterEventHandlers() {
      string[] properties = sourcePath.Split('.');
      object current = source;
      foreach (string property in properties) {
        TryUnhookFromChangedEvent(current, property + "Changed");
        MethodInfo mInfo = current.GetType().GetProperty(property, Flags).GetGetMethod(true);
        object next = mInfo.Invoke(current, null);
        if (next == null) return;
        current = next;
      }
    }

    // DO NOT RENAME (string reference to this method name in CreateAndAddDynamicEventHandler)
    private void ExecuteBinding(object sender) {
      string[] sourceProperties = sourcePath.Split('.');
      object cSource = source;
      PropertyInfo bindingProperty = null;
      bool reregister = false;
      for (int i = 0; i < sourceProperties.Length; i++) {
        if (cSource == null) return;
        string property = sourceProperties[i];
        if (reregister) TryHookToChangedEvent(cSource, property + "Changed");
        if (cSource == sender) reregister = true;
        bindingProperty = cSource.GetType().GetProperty(property, Flags);
        object next = bindingProperty.GetGetMethod(true).Invoke(cSource, null);
        cSource = next;
      }

      string[] targetProperties = targetPath.Split('.');
      object cTarget = target;
      for (int i = 0; i < targetProperties.Length - 1; i++) {
        cTarget = cTarget.GetType().GetProperty(targetProperties[i], Flags).GetGetMethod(true).Invoke(cTarget, null);
        if (cTarget == null) return;
      }
      MethodInfo setter = cTarget.GetType().GetProperty(targetProperties.Last(), Flags).GetSetMethod(true);
      if (cSource.GetType().IsValueType)
        setter.Invoke(cTarget, new object[] { cSource });
      else if (cSource is ICloneable)
        setter.Invoke(cTarget, new object[] { ((ICloneable)cSource).Clone() });
      else throw new InvalidOperationException("Can only bind to targets which are either a ValueType or an ICloneable.");
    }

    private bool TryHookToChangedEvent(object obj, string property) {
      EventInfo eInfo = obj.GetType().GetEvent(property, Flags);
      if (eInfo != null) {
        Type[] methodParams = eInfo.EventHandlerType.GetMethod("Invoke").GetParameters().Select(x => x.ParameterType).ToArray();
        if (!eventHandlerCache.ContainsKey(methodParams[1]))
          CreateAndAddDynamicEventHandler(eInfo, methodParams);
        eInfo.AddEventHandler(obj, eventHandlerCache[methodParams[1]]);
      }
      return eInfo != null;
    }

    private bool TryUnhookFromChangedEvent(object obj, string property) {
      EventInfo eInfo = obj.GetType().GetEvent(property, Flags);
      if (eInfo != null) {
        Type[] methodParams = eInfo.EventHandlerType.GetMethod("Invoke").GetParameters().Select(x => x.ParameterType).ToArray();
        if (eventHandlerCache.ContainsKey(methodParams[1]))
          eInfo.RemoveEventHandler(obj, eventHandlerCache[methodParams[1]]);
      }
      return eInfo != null;
    }

    private void CreateAndAddDynamicEventHandler(EventInfo eInfo, Type[] methodParams) {
      Type[] instanceMethodParams = new Type[] { GetType() }.Concat(methodParams).ToArray();
      DynamicMethod dynamicEventHandler = new DynamicMethod("sourceChanged", null, instanceMethodParams, GetType());
      MethodInfo executeBindingMethodInfo = GetType().GetMethod("ExecuteBinding", Flags);
      ILGenerator iLG = dynamicEventHandler.GetILGenerator();
      iLG.Emit(OpCodes.Ldarg_0); // load 'this' pointer
      iLG.Emit(OpCodes.Ldarg_1); // load sender parameter
      iLG.Emit(OpCodes.Call, executeBindingMethodInfo); // call method to execute the binding
      iLG.Emit(OpCodes.Ret);
      eventHandlerCache.Add(methodParams[1], dynamicEventHandler.CreateDelegate(eInfo.EventHandlerType, this));
    }
  }
}