始终运行任务中的异常处理

Question

After countless hours of testing,searching, and asking question i'm still stuck on 'always-running' tasks, or does that not exist in async io/ parallell programming?

currently I have a program that polls webapi service (soap) to get status of sensor (IOT based).

The hiearchy of our programming is just flatten down, step1 then step2 then step3 and so on and so forth.

Now the problem here is if step 3 fails with an exception step 4-6 will not be executed.

So i had in mind to split up in tasks each with there coresponding task. For instance; step 1 start program connect to webapi, step 2 get a list of sensors in memory, step 3 start tasks.

There are 3 main tasks: 1 task for getting the statusses for the sensors, another to check if the webserver is online, and the last one to ask the server if there are new sensors of old one getting deleted.

so step 4 to step 6 are 3 tasks. -> these task will always be running since there are just polling the server, this happens on timer ticks

step 4 each 1 second, step 5 each 10 seconds, and step 6 every minute.

Oke so far so good, I probably call var task1 = Task.Run( () => somevoidtask);

Question: How to handle here if one of the tasks has failed and needs to be restarted? I was testing around and came across autoresetevent. How will I handle the exception (gets logged) and restart that task?

On microsoft docs i commonly see:

var task = Task.Run();
task.wait();
if(task.status == task.faulted)
{
  get exception
}

just simple pseudo.

my current test project I have this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace taskTest
{
    public class Program
    {
        public static void Main(string[] args)
        {

            var source = new CancellationTokenSource(20000);
            var source2 = new CancellationTokenSource();
            var source3 = new CancellationTokenSource();

            var token1 = source.Token;
            var token2 = source2.Token;
            var token3 = source3.Token;

            Task1(token1);
            Task2(token2);
            Task3(token3);

            Console.ReadLine();

        }





        private static void Task1(CancellationToken token)
        {
            while (true)
            {
                if (token.IsCancellationRequested)
                {
                    Console.WriteLine("Cancellation is request for this task.");
                    return;
                }
                Task.Delay(1000);
            }
        }

        private static void Task2(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                try
                {
                    throw new NullReferenceException();
                }
 

           catch (Exception ex)
            {
                
            }
        }
        Console.WriteLine("Task2 is cancelled");
    }

    private static void Task3(CancellationToken token)
    {
        Task.Run(async () =>
        {
            while (!token.IsCancellationRequested)
            {
                Console.WriteLine($"Task3: getting executed every 10 second");
                await Task.Delay(10000);
            }
            Console.WriteLine("Task3 is cancelled");
        });
    }
}

}

Also maybe a best practice I assume not all my code is good.

Answer 1

Exceptions can be tricky since it can be difficult to know if they have put the program in an unrecoverable state or not. If that has happened the best thing to do is to let your program crash and rely on an external system to restart it.

For exceptions you are reasonably sure are safe to continue from, just catch them, log it, and continue. Or perform any other recovery process needed.

I do not like any of your examples. Task1/2 will just block until canceled and only task2 have any kind of exception handling.

For reoccurring tasks I would recommend a timer, using things like Task.Delay is just a async-wrapper around a timer anyway. Use one that triggers on a background thread if you are sure there are no thread safety issues. Handle all exceptions that you consider safe to catch in the event-handler of the timer, consider adding an unhandled exception handler to log any other exceptions before closing your application. Making your application a service is a decent way to let windows deal with restarting your application if it fails.