using System;

using System.Linq;

using System.Collections.Generic;

using System.Reflection;

​

namespace Example

{

    interface ITask

    {

    }

​

    class TaskA : ITask

    {

        public TaskA(ISingletonA dependencyA) {} 

        public string Test => "I am a TaskA";

    }

    class TaskB : ITask

    {

        public TaskB(ISingletonA dependencyA, ISingletonB dependencyB) {} 

        public string Test => "I am a TaskB";

    }

​

    class TaskC : ITask

    {

        public TaskC(ISingletonA dependencyA, string runtimeParameter) {} 

        public string Test => "I am a TaskC";

    }

​

​

    interface ISingletonA {}

    interface ISingletonB {}

​

​

    interface IMyTaskFactory { T Resolve<T>() where T : ITask; }

​

    class MyTaskFactory : IMyTaskFactory

    {

        private readonly ISingletonA _singletonA;

        private readonly ISingletonB _singletonB;

​

        public MyTaskFactory(ISingletonA singletonA, ISingletonB singletonB)

        {

            _singletonA = singletonA;

            _singletonB = singletonB;

        }

​

        public T Resolve<T>() where T : ITask

        {

            if (typeof(T) == typeof(TaskA)) return (T)(object)GetTaskA();

            if (typeof(T) == typeof(TaskB)) return (T)(object)GetTaskB();

            if (typeof(T) == typeof(TaskC)) return (T)(object)GetTaskC();

            throw new ArgumentException(string.Format("Type not supported: {0}", typeof(T).FullName));

        }

​

        protected TaskA GetTaskA()

        {

            return new TaskA(_singletonA);

        }

​

        protected TaskB GetTaskB()

        {

            return new TaskB(_singletonA, _singletonB);

        }

​

        protected TaskC GetTaskC()

        {

            return new TaskC(_singletonA, "Other runtime parameter");

        }

    }

​

    class Scheduler

    {

        protected readonly IMyTaskFactory _taskFactory;

​

        public Scheduler(IMyTaskFactory taskFactory)

        {

            _taskFactory = taskFactory;

        }

        public void Start()

        {

            var taskA = _taskFactory.Resolve<TaskA>();

            var taskB = _taskFactory.Resolve<TaskB>();

            var taskC = _taskFactory.Resolve<TaskC>();

            Console.WriteLine("{0};{1};{2}", taskA.Test, taskB.Test, taskC.Test);

        }

    }

    public class Program

    {

        public static void Main()

        {

            var scheduler = new Scheduler(new MyTaskFactory(null,null));

            scheduler.Start();

        }

    }

}