using System;

using System.Linq;

using System.Linq.Expressions;

using System.Collections.Generic;

​

public class SourceClass

{

    public int SourceNumber { get; set; }

    public string Name;

}

​

public class TargetClass

{

    public int TargetNumber { get; set; }

    public int SourceNumber { get; set; }

    public string SourceName { get; set; }

}

​

public static class Binder

{

    public static Binder<T, U> Bind<T, U>(T source, U target)

    {

        return new Binder<T, U>();

    }

    public static Binder<T, U> Bind<T, U>()

    {

        return new Binder<T, U>();

    }

}

​

public interface IBindMap<T,U>

{

    void Apply(T source, U target);

    void Apply(U source, T target);

}

​

public class BindMap<T,U,CP> : IBindMap<T,U>

{

    public Expression<Func<T,CP>> SourceProp { get; set; }

    public Expression<Func<U,CP>> TargetProp { get; set; }

    public BindMap() {}

    public BindMap(Expression<Func<T,CP>> sourceProp, Expression<Func<U,CP>> targetProp) {

        SourceProp = sourceProp;

        TargetProp = targetProp;

    }

    public void Apply(T source, U target)

    {

        var sourceParam = Expression.Parameter(typeof(T));

        var sourceL = Expression.Invoke(SourceProp, sourceParam);

        var assignParam = TargetProp.Parameters.First();

        var assignTarget = Expression.Assign(TargetProp.Body, sourceL);

        var applyL = Expression.Lambda<Action<T, U>>(assignTarget, sourceParam, assignParam);

        applyL.Compile()(source, target);

    }

    public void Apply(U source, T target)

    {

        var sourceParam = Expression.Parameter(typeof(U));

        var sourceL = Expression.Invoke(TargetProp, sourceParam);

        var assignParam = SourceProp.Parameters.First();

        var assignTarget = Expression.Assign(SourceProp.Body, sourceL);

        var applyL = Expression.Lambda<Action<U, T>>(assignTarget, sourceParam, assignParam);

        applyL.Compile()(source, target);

    }

}

​

public class Binder<T,U>

{

    List<IBindMap<T, U>> bindings { get; set; }

    public Binder<T, U> Map<CP>(Expression<Func<T,CP>> sourceProp, Expression<Func<U,CP>> targetProp)

    {

        if (bindings == null)

            bindings = new List<IBindMap<T,U>>();

        bindings.Add(new BindMap<T, U, CP>(sourceProp, targetProp));

        return this;

    }

    public void Apply(T source, U target)

    {

        foreach (var binding in bindings)

            binding.Apply(source, target);

    }

    public void Apply(U source, T target)

    {

        foreach (var binding in bindings)

            binding.Apply(source, target);

    }

}

​

public class Program

{

    public static void Main()

    {

        // define how an instance of one class will map properties to another class via lambdas

        var sourceTargetBinder = Binder.Bind<SourceClass, TargetClass>()

            .Map(sc => sc.SourceNumber, tc => tc.SourceNumber)

            .Map(sc => sc.Name, tc => tc.SourceName);

        // take note that this works on accessors in addition to properties but doesn't verify the ability to bi-directionally bind

        // define instances to apply the binding to

        var source = new SourceClass() { SourceNumber = 42, Name = "FourtyTwo" };

        var target = new TargetClass();

        // apply the binding from source instance to target instance

        target.Dump();

        sourceTargetBinder.Apply(source, target);

        target.Dump();

        // modify the target and bind the target back to the source (bi-directional bind)

        target.SourceNumber = 43;

        target.SourceName = "FourtyThree";

        sourceTargetBinder.Apply(target, source);

        source.Dump();

    }

}