public class FrontLoadContext<TActivity>
    {
        public void Plan(DateTime projectStart)
        {
            //Create the wrapped object that will play the role of project
            var project = _projectCreator.Create();
            project.FrontloadFrom(projectStart);
        }

        internal static void FrontloadFrom(IActivityContract activity, DateTime projectStart)
        {
            IActivityContract predecessor =
                ((IActivityRole) activity).Predecessors.Cast<IActivityContract>().OrderByDescending(a => a.End).
                    FirstOrDefault();
            activity.Start = predecessor == null ? projectStart : predecessor.End;
        }

        internal static IEnumerable<IActivityRole> GetPredecessors(IActivityContract activity)
        {
            return from act in activity.Dependencies
                   select DynamicCreator<IActivityContract, IActivityRole>.GetCreator(act).Create();
        }

        internal static void FrontloadFrom(IProjectContract project, DateTime projectStart)
        {
            //select an activity which has not been planned
            IEnumerable<IActivityRole> activities = from task in project.Tasks
                                                     let act =
                                                         DynamicCreator<IActivityContract, IActivityRole>.GetCreator(
                                                             task).Create()
                                                     where !act.Planned && act.Predecessors.All(a => a.Planned)
                                                     select act;
            while (activities.All(a => a.Planned))
            {
                foreach (var activity in activities)
                {
                    activity.FrontloadFrom(projectStart);
                }
            }
        }

        internal interface IActivityContract
        {
            IEnumerable<TActivity> Dependencies { get; }
            DateTime End { get; }
            DateTime Start { get; set; }
            bool HasBeenPlanned { get; }
        }

        public interface IActivityRole
        {
            IEnumerable<IActivityRole> Predecessors { get; }
            bool Planned { get; }
            void FrontloadFrom(DateTime projectStart);
        }

        internal interface IProjectContract
        {
            List<TaskData> Tasks { get; }
        }


        internal interface IProjectRole
        {
            void FrontloadFrom(DateTime projectStart);
        }

        private readonly DynamicCreator<IProjectContract, IProjectRole>.ICreator _projectCreator;

        public FrontLoadContext(ProjectData project)
        {
            //Create the internal representation of the acting objects making sure they adhere to the given contracts
            _projectCreator = DynamicCreator<IProjectContract, IProjectRole>.GetCreator(project);

            //Add role methods to the project acting objects
            if (!_projectCreator.IsFinalized)
            {
                _projectCreator.Add<DateTime>(proj => proj.FrontloadFrom(default(DateTime)),
                                              (p, start) => FrontloadFrom(p, start));
            }

            //Add role methods to the activity acting objects
            DynamicCreator<IActivityContract, IActivityRole>.ICreator activityCreator =
                DynamicCreator<IActivityContract, IActivityRole>.GetCreator<TActivity>();
            if (!activityCreator.IsFinalized)
            {
                activityCreator.Add<DateTime>(a => a.FrontloadFrom(default(DateTime)),
                                              (a, start) => FrontloadFrom(a, start));
                activityCreator.Add(a => a.Predecessors, a => GetPredecessors(a));
                activityCreator.Add(a => a.Planned, a => a.HasBeenPlanned);
                activityCreator.Create();
            }
        }
    }