Task with infinite cycle

Question

I'm new in C#, I've gone to it from Delphi. So may be I do something wrong. My app (windows service) make tasks to control on-off states and count "on" time. I've tried to use Task.Delay(x), but it seems I catch deadlocks... Main idea make tasks with infinite cycle which performs every x ms. I don't know if I could use the Timer for executing part code in lambda method of task...?

        int TagCnt = DataCtrl.TagList.Count;                     
        stopExec = false;
        if (TagCnt != 0)
        {                
            tasks = new Task[TagCnt];                
            for (int i = 0; i <= TagCnt - 1; i++)
            {                    
                int TempID = i;
                tasks[TempID] = Task.Run(async () => // make threads for parallel read-write tasks // async
                {                                            
                    Random rand = new Random();
                    TimeSpan delay = TimeSpan.FromMilliseconds(rand.Next(1000, 1500))                                              
                    try
                    {
                        while (!stopExec)
                        {                               
                        cToken.ThrowIfCancellationRequested();                          
                        //do basic job here
                        await Task.Delay(delay, cToken);
                        }//while end                            
                    }
                    catch (...)
                    {
                    ...
                    }                                            
                }, cToken);                   
            }

Answer 1

A couple of things went wrong here:

• The tasks you're creating are completed instantly, in your case Task.Factory.StartNew returns Task<Task> because of the async lambda. To make it work as expected, unwrap the inner task with Task.Unwrap. Also, remove TaskCreationOptions.LongRunning, you don't need it here:

tasks[TempID] = Task.Factory.StartNew(async () => { ...}).Unwrap();

• Alternatively, use Task.Run, it unwraps automatically (more about this):

tasks[TempID] = Task.Run(async () => { ...});

• Besides, there's no synchronization context installed on a Windows service thread by default. Thus, the code after await Task.Delay() will be executing on a new pool thread each time, you should be ready for this.

• Task.Delay is a bit different from a periodic timer. It will delay the execution. Use Stopwatch to calculate how much to delay for:

// beginning of the loop
stopwatch.Reset();
stopwatch.Start();

// the loop body
// ...

// end of the loop
await Task.Delay(Math.Max(500-Stopwatch.ElapsedMilliseconds, 0));