Wsrtjtyk

I'm new to background work (and generally in Task usage) and have a doubts about my implementation.

(Note: If you think it's too long, let me know by comment and I'll shorten it)

Assume a WCF service which returns currencys rates:

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]

public class RatesServiceSvc : IGetRatesService

• The RatesServiceSvc depends on IRatesService(singelton).


• 
  IRatesService depens on IRatesQueueDispatcher.
  holds ratesCache dictionary. and in its constructor calls to RunDispatcher(_ratesQueue, _dispatcherCancellationTokenSource);

The internal implementation of the IRatesService is like this: The service instantiate a third party queue which gets from the network the current rates and pushes them as events to the queue (endlessly). In order to fetch the events I need to invoke the IRatesQueueDispatcher.Run(...) that runs backgroun loop:

The IRatesService implementation:

private void RunDispatcher(Queue queue, CancellationTokenSource dispatcherCancellationTokenSource)

    {

        Task<TaskCompletionCause> dispatcher = Task.Run(() => _queueDispatcher.Run(queue, dispatcherCancellationTokenSource.Token));

        dispatcher.ContinueWith((dispatcherTask) =>

        {

            HandleRunningTaskTermination(dispatcherTask.Result);

        });

    }

IRatesQueueDispatcher.Run() Imlementation:

while (!cancellationToken.IsCancellationRequested && IsRatesQueueOk(eventsCount))

        {

            eventsCount = ratesQueueToDispatch.Dispatch();

            if (eventsCount < 0)

            {

                Thread.Sleep(_sleepTimeWhenReutersQueueEmpty);

            }

        }

The queue.Dispach() call, leads to invoke (in the same thread) to the implementation of EventClient.ProcessEvent(event) (which registered in the initialization phase). The data fetched from the events inserted to the rateCache (in this case it's a ConcurrentDictionary)

The application needs:

• The background loop will run endlessly.


• If background loop fails for some reason I need to know it immediately.


• If application has another issue I need to kill the background task.

The question:
Do my solution of running the backgroun work by Task.Run(...).ContinueWith(...) is Ok? I read in some palces about "Fire and Forget" Dangers (here
and here) also I know .NET 4.5.2 suggests the HostingEnvironment.QueueBackgroundWorkItem

but I'm not sure if it's the appropriate solution for me. Because:

1. I need to know if the worker failed from its internal reason.




2. It seems to me that the main purpose of the HostingEnvironment.QueueBackgroundWorkItem is to promise the finish of the running task before application_end. For my needs There isn't meaning of running the background work when application ends, and also vice versa - If background failed there is no meaning of the application to run without it. For that reason I implemented the HandleRunningTaskTermination() to recycle the application by invoke System.Web.HttpRuntime.UnloadAppDomain();.

After all, I'm worried about my implemetation and I'm looking for a better solution. There is better??