Data-controlled Processes Application Design

using System.Collections;
using System.Collections.Generic;

namespace DataDriven
{
    public abstract class DataProcessSet : IEnumerable<AddProcessParams>
    {
        private readonly List<AddProcessParams> processes = new List<AddProcessParams>();
        private readonly List<InputRequirement> setInputRequirements = new List<InputRequirement>();
        private readonly List<AddProcessParams> possibleLastProcesses = new List<AddProcessParams>();

        /*protected List<ProcessInputRequirements> OverAllInputRequirement
        {
            get { return overAllInputRequirements; }
        }*/
        internal protected void AddSetInputRequirement(InputRequirement requirement)
        {
            setInputRequirements.Add(requirement);
        }
        public void Add(IDataProcess process)
        {
            var param = new AddProcessParams(process);
            AddActions(param);
            processes.Add(param);
            AddToPossibleLastProcesses(param);
        }

        protected virtual void AddActions(AddProcessParams param)
        {
        }

        protected virtual void AddActions(DataProcessSet set)
        {
        }
        public void Add(DataProcessSet set)
        {
            AddActions(set);
            IEnumerable<AddProcessParams> enumerable = set.FlattenProcesses() ?? set.Processes;
            foreach (AddProcessParams param in enumerable)
            {
                foreach (InputRequirement requirement in set.setInputRequirements)
                    param.InputRequirements.AddOverAllRequirement(requirement);
                processes.Add(param);
            }
            AddToPossibleLastProcesses(set);
        }

        protected virtual void AddToPossibleLastProcesses(AddProcessParams param)
        {
            possibleLastProcesses.Add(param);
        }

        protected virtual void AddToPossibleLastProcesses(DataProcessSet set)
        {
            foreach (AddProcessParams param in set.possibleLastProcesses)
                possibleLastProcesses.Add(param);
        }

        protected internal List<AddProcessParams> Processes
        {
            get { return processes; }
        }

        protected virtual IEnumerable<AddProcessParams> FlattenProcesses()
        {
            return null;
        }

        public IEnumerator<AddProcessParams> GetEnumerator()
        {
            return Processes.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        protected internal int ProcessCount { get { return processes.Count; } }

        public List<AddProcessParams> PossibleLastProcesses
        {
            get { return possibleLastProcesses; }
        }
    }


    public class DataProcessParallel : DataProcessSet
    {
        protected override IEnumerable<AddProcessParams> FlattenProcesses()
        {
            var forbidden = new List<IDataProcess>();
            foreach (AddProcessParams param in Processes)
                forbidden.Add(param.Process);
            var requirement = new TrackRestrictionRequirement
            {
                RestrictionType = TrackRestrictionRequirement.RestrictionTypes.Forbid
            };
            requirement.AffectedProcesses.AddRange(forbidden);
            foreach (AddProcessParams param in Processes)
            {
                param.InputRequirements.AddOverAllRequirement(requirement);
                yield return param;
            }
        }
    }
    public class DataProcessSequence : DataProcessSet
    {
        private List<AddProcessParams> previous;

        protected override void AddActions(AddProcessParams process)
        {
            if (previous != null)
                process.InputRequirements.AddOverAllRequirement(
                    new SequenceRequirement(previous.ConvertAll(par => par.Process)));

            previous = new List<AddProcessParams> { process };
        }

        protected override void AddActions(DataProcessSet set)
        {
            if (previous != null)
                set.AddSetInputRequirement(new SequenceRequirement(previous.ConvertAll(par => par.Process)));
            previous = new List<AddProcessParams>(set.PossibleLastProcesses);
        }

        protected override void AddToPossibleLastProcesses(AddProcessParams param)
        {
            PossibleLastProcesses.Clear();
            PossibleLastProcesses.Add(param);
        }

        protected override void AddToPossibleLastProcesses(DataProcessSet set)
        {
            if (set.PossibleLastProcesses.Count > 0)
                AddToPossibleLastProcesses(set.PossibleLastProcesses[set.PossibleLastProcesses.Count - 1]);
            else if (set.ProcessCount > 0)
                AddToPossibleLastProcesses(set.Processes[set.ProcessCount - 1]);
        }
    }
    public class DataProcessLooseSet : DataProcessSet
    {
    }
}