How to design a processor that loads objects from a runtime configuration

Question

I am implementing a scheduler. As part of its core logic it processes a custom object Schedule. Basically it iterates over an array of schedules and try to process it. The problem is who ever creates a Schedule needs to register it with the container using an ISchedule interface. My Scheduler then pulls all the ISchedule references from the container. SO far this is working but it does not have the flexibility of loading the schedules runtime. What design and implementation I can adapt to implement a Scheduler that can load those Schedules run time. I am giving some sample code.

Something that is coming to my mind is having the developers writing a json representation of the Schedules and put that inside a config or implementing an endpoint that returns that config to the Scheduler. But can I avoid this? I want the Scheduler to be completely agonistic of developer code.

Answer 1

You can use the factory to register information about schedule classes. And dynamically change the call interval by finding the schedule by Id. You register in the container: <IScheduleFactory,ScheduleFactory> and <IScheduleManager,ScheduleManager>

public interface ISchedule
{
    public string Id { get; set; }
    public TimeSpan Interval { get; set; }

    public DateTime? LastExecution { get; set; }

    public bool CanStart { get; }

    void Start();
    void Stop();
}

public sealed class Schedule : ISchedule
{
    public string Id { get; set; }
    public TimeSpan Interval { get; set; }
    public DateTime? LastExecution { get; set; }
    public bool CanStart {
        get
        {
            lock (_sync)
            {
                return !LastExecution.HasValue || LastExecution.Value.Add(Interval) >= DateTime.UtcNow;
            }
        }
    }

    private readonly object _sync = new object();
    
    public void Start()
    {
        lock (_sync)
        {
            if (!LastExecution.HasValue || LastExecution.Value.Add(Interval) >= DateTime.UtcNow)
            {
                // DO WORK
                LastExecution = DateTime.UtcNow;
            }
        }
        
    }

    public void Stop()
    {
        throw new NotImplementedException();
    }
}

public interface IScheduleFactory
{
    ISchedule Create();
}

public sealed class ScheduleFactory: IScheduleFactory
{
    private readonly IScheduleManager _manager;

    public ScheduleFactory(IScheduleManager manager)
    {
        _manager = manager;
    }

    public ISchedule Create()
    {
        var schedule = new Schedule();
        _manager.Register(schedule);

        return schedule;
    }
}

public interface IScheduleManager
{
    void Register(ISchedule schedule);
    ISchedule Get(string id);

    void Start();
    void Stop();

}
public sealed class ScheduleManager : IScheduleManager
{
    private readonly Dictionary<string,ISchedule> _items =  new Dictionary<string, ISchedule>();
    private readonly object _sync = new object();
    public void Register(ISchedule schedule)
    {
        lock (_sync)
        {
            if (_items.ContainsKey(schedule.Id))
                _items.Add(schedule.Id, schedule);
        }
        
    }

    public ISchedule Get(string id)
    {
        lock (_sync)
        {
            if (_items.ContainsKey(id))
                return _items[id];
        }

        return null;
    }

    private bool _isStart;
    public void Start()
    {
        _isStart = true;
        while (_isStart)
        {
            ISchedule[] array = null;
            lock (_sync)
            {
                array = _items.Values.ToArray();
            }

            foreach (var schedule in array)
            {
                if (schedule.CanStart)
                    Task.Factory.StartNew(()=>schedule.Start());
            }
        }
        
    }

    public void Stop()
    {
        _isStart = false;
    }
}