Hi,

I would recommend using https://www.hangfire.io/

Thanks I will check it out

Yep HangFire is recommended at an alternative, the built in facility was removed from v8. :-)

I've blogged about Hangfire as well, Hangfire is fantastic: https://cultiv.nl/blog/using-hangfire-for-scheduled-tasks-in-umbraco/

Hi Sebastiaan.

Can you Dependency inject, like below? And how would you differ what methods to run between environments?

    using Hangfire;
    using Hangfire.Server;

    namespace Cultiv.Hangfire
    {
        public class ScheduleHangfireJobs
        {
            private readonly IContentService _contentService;

            public void DoSomething(IContentService contentService)
            {
                _contentService = contentService;
                RecurringJob.AddOrUpdate(() => DoIt(null), Cron.HourInterval(12));
            }

            public void DoIt(PerformContext context)
            {
                // Do something!
            }
        }
    }

Hi,

Also you could use the runtime state to workout what type of server you are on (master, slave, standalone) as you probably don't want to run your scheduled task on all the severs

see https://our.umbraco.com/Documentation/Reference/Scheduling/#using-runtimestate

I ran into problems trying inject dependencies into the "DoSomething" method. I actually needed the IContentService too, oddly enough. I don't remember the details of whether it just wouldn't compile or if the service wasn't instantiated properly, but I couldn't get it working.

The best (i.e. quickest...this was a project with a tight deadline and budget) solution I came up with was to make a controller action that performed the work I needed done. Inside the "DoSomething" method, I made a webrequest to the url of my controller action. It got the job done and it's been running like a champ in production, every 15 minutes :-)

There are probably better solutions, but I just wanted to share that approach in case someone has a similar issue and this happens to be 'good enough'

In the below example, the values I pull from my ConfigurationHelper class are the url and parameters of the Controller action I created.

public class ScheduleHangfireJobs
{
    public void DoSomething()
    {
        RecurringJob.AddOrUpdate(() => DoIt(null), "*/15 * * * *");
    }

    public void DoIt(PerformContext context)
    {
        //Since the import requires umbraco dependencies, it is easier
        //to just request it over the web than manage the dependencies in the background
        //task.
        WebClient client = new WebClient();
        var url = ConfigurationHelper.GetConfigSetting<string>("ProductionImportUrl");
        var key = ConfigurationHelper.GetConfigSetting<string>("ProductionImportKey");
        string downloadString = client.DownloadString($"{url}?key={key}&source=ScheduledJob");
    }
}

Yep, pretty sure that's what I started with. Again, I don't remember the details of why I bailed, unless it's something like the concrete version of the content service that you'd inject from the startup class not having everything it needs at the point it runs, then errors when you try to use the injected object in your Hangfire class.

I could be totally wrong and maybe I just missed something obvious.

Scheduled Tasks in Umbraco 8 are handled via classes inherited from RecurringTaskBase. Here is a scheduled task we run on a live U8 project:

[ComposeAfter(typeof(SettingsDataComposer))]
public class SharePriceRunnerComposer : ComponentComposer<SharePriceRunnerComponent> {
}

public class SharePriceRunnerComponent : IComponent {

    private IProfilingLogger _logger;
    private IRuntimeState _runtime;
    private BackgroundTaskRunner<IBackgroundTask> _sharePriceRunnerRunner;
    private readonly SettingsDataComponent _settings;
    private readonly IContentService _contentService;

    public SharePriceRunnerComponent(IProfilingLogger logger, IRuntimeState runtime, SettingsDataComponent settings, IContentService contentService) {
        _settings = settings;
        _logger = logger;
        _runtime = runtime;
        _contentService = contentService;
        _sharePriceRunnerRunner = new BackgroundTaskRunner<IBackgroundTask>("GetSharePrice", _logger);
    }

    public void Initialize() {
        int delayBeforeWeStart = 60000; // 60000ms = 1min
        int howOftenWeRepeat = 1800000; //300000ms = 5mins 1800000 = 30 mins

        if (_settings.IsScheduledTaskServer(Environment.MachineName) && _settings.DoScheduledTasks) {
            _logger.Info<GetSharePrice>("Initialize- GetSharePrice - {ServerRole}", _runtime.ServerRole);

            if (_settings.SharePriceFreqMinutes > 0) {
                howOftenWeRepeat = (_settings.SharePriceFreqMinutes * 60000);
            }

            var task = new GetSharePrice(_sharePriceRunnerRunner, delayBeforeWeStart, howOftenWeRepeat, _runtime, _logger, _settings, _contentService);

            //As soon as we add our task to the runner it will start to run (after its delay period)
            _sharePriceRunnerRunner.TryAdd(task);
        }
    }

    public void Terminate() {
    }
}

// Now we get to define the recurring task
public class GetSharePrice : RecurringTaskBase {
    private IRuntimeState _runtime;
    private IProfilingLogger _logger;
    private SettingsDataComponent _settings = null;
    private readonly IContentService _contentService;

    public GetSharePrice(IBackgroundTaskRunner<RecurringTaskBase> runner, int delayBeforeWeStart, int howOftenWeRepeat, IRuntimeState runtime, IProfilingLogger logger, SettingsDataComponent settings, IContentService contentService)
        : base(runner, delayBeforeWeStart, howOftenWeRepeat) {
        _runtime = runtime;
        _logger = logger;
        _settings = settings;
        _contentService = contentService;
    }

    public override bool PerformRun() {


        SharePriceService pricesservice = new SharePriceService(_settings);
        ReturnClass outcome = pricesservice.UpdateSharepriceCache();

        if (!outcome.Success) {
            string errormessage = outcome.GetBothMessages();
            _logger.Error<GetSharePrice>("Get Share Price-{ServerRole}", _runtime.ServerRole);
            _logger.Error<GetSharePrice>("Error {errormessage}", errormessage);
        } else {
            _logger.Info<GetSharePrice>("Get Share Price successfull-{ServerRole}", _runtime.ServerRole);
        }

        // If we want to keep repeating - we need to return true
        // But if we run into a problem/error & want to stop repeating - return false
        return true;
    }

    public override bool IsAsync => false;
}

Our setup has load balancing so we use the machine name to only set the process to run on a specific machine.

Also we need the settings from "SettingsDataComponent settings", so we ensure that that one is initialised before this one

is working on a reply...