Task issue with Powershell and TaskScheduler

Question

I am writing a C# library (.NET 4.6.1) that will use Tasks to be able to run several snippets of code in the background. This library will be called by a Powershell script that is triggered from a TaskScheduler item

When I do testing by launching Powershell, and then calling the library, all is working correctly. However, through the TaskScheduler it does not work, and I can replicate this behavior issue with a console application.

Main library thread:

public class MainLibrary {
private static HttpClient g_httpclient_Main = new HttpClient();
private static List<Task> g_list_Tasks = new List<Task>();

public void EntryPoint() {
 SetupTasks();

 foreach (Task _t_List in g_list_Tasks)
 {
   _t_List.Start();
 }
 Task.WaitAll(g_list_Tasks.ToArray());
}
}

Each of the tasks were created before the foreach loop in a separate function/method of the MainLibrary class like this:

private void SetupTasks() {
  Task _task_TollGate = new Task(() =>
  {
     QueueEndpointCall();
  });
  g_list_Tasks.Add(_task_TollGate);
}


private async Task QueueEndpointCall()
{
   try {
     HttpResponseMessage _httprm = await g_httpclient_Main.GetAsync("http://www.google.com");
     _string_HTTP = await _httprm.Content.ReadAsStringAsync();
     ....other code
   }
   catch (Exception e) {
     File.WriteLine...
   }
}

When I run the console application and put a breakpoint, when the GetAsync is hit and run, it will jump back to the main thread which if I understand correctly is fine/correct. Then hitting the Task.WaitAll line, seemingly the background Task has finished, but the placeholder I have in the snippet "...other code" does not execute. Launching Powershell manually, and calling the library, works fine.

Any suggestions here ? I am considering upgrading to .NET v8.0, however I don't have the resources at this moment to do that and would like to get this working in .NET 4.6.1

Edit (7-Jan-2025) - I migrated to .NET 8 with no success, and even tried the suggestion to locally declare HttpClient although I wouldn't think that's the problem, and still the "...other code" is not being executed. I believe an error is being swallowed as I don't see an error log file from the try/catch that is wrapping the HttpClient call.

Thanks.

"it will jump back to the main thread" - Only if there is a synchronization context, like in a UI program. Code like static List<Task> looks really scary to me, threaded and async code tend to be much simpler and safer when everything is immutable and pure, i.e. no side effects, only parameters and return values. And if this is a library I would recommend targeting .net standard, that way it is usable in both .net 4.x and 5+. — JonasH
– JonasH, Commented Jan 7 at 7:54
As a side note, the underscore prefix is intended for private instance fields, not for local variables. The _t_List and _task_TollGat are local variables, and should not be prefixed with underscore. See C# identifier naming rules and conventions. — Theodor Zoulias
– Theodor Zoulias, Commented Jan 8 at 8:04

Theodor Zoulias · Accepted Answer · 2025-01-08 13:17:53Z

1

You have made a wrong assumption about what each task in the g_list_Tasks represents. It represents the launching of an asynchronous QueueEndpointCall operation. It doesn't represent the completion of this operation. When a task in the g_list_Tasks completes it means that the QueueEndpointCall has just been launched, not that it has been completed. The way you have defined your tasks, you have deprived yourself from all means to know when the QueueEndpointCall operations complete. There are two solutions to this problem:

Avoid using the Task constructor, and use the Task.Run instead (.NET Framework 4.5+). The Task.Run understands async delegates, and returns a task that represents both the launching and completion of the asynchronous operation. This is the recommended solution.
Keep using the the Task constructor, but use nested Task<Task> instances instead of simple Task. The inner task of this nested structure represents the completion of the asynchronous operation:

    private static List<Task<Task>> g_list_Tasks = new List<Task<Task>>();

    // ...

    Task<Task> _task_TollGate = new Task<Task>(() => QueueEndpointCall());

    // ...

    Task.WaitAll(g_list_Tasks.Select(t => t.Unwrap()).ToArray());

The Unwrap method (.NET Framework 4.0+) unwraps a nested Task<Task> to a simple Task that represents both tasks, the outer and the inner.

As a side note, when you use the Task.Start method your are advised to specify the TaskScheduler parameter, to avoid making your code sensitive to the ambient TaskScheduler.Current. For details see the CA2008 guideline. Correct usage:

_t_List.Start(TaskScheduler.Default);

But you should probably avoid all this complexity and use the Task.Run instead.

edited Jan 8 at 13:17

answered Jan 8 at 7:57

Theodor Zoulias

46.1k8 gold badges112 silver badges155 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

maegus Jan 8 at 13:09

Hi Theodor, will review this carefully to make sure i have the right understanding, and adjust my code and try it out.

maegus Jan 8 at 14:22

Using Task.Run worked, thanks Theodor!

maegus · Accepted Answer · 2025-01-08 06:29:41Z

0

I was able to get this to work correctly:

private readonly static HttpClient g_httpclient_Main = new HttpClient();

public void EntryPoint(string f_string_Metadata)
{
    System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
    List<Task> g_list_Tasks = new List<Task>();
    SetupTasks(g_list_Tasks);

    foreach (Task _t_List in g_list_Tasks)
    {
        _t_List.Start();
    }
    Task.WaitAll(g_list_Tasks.ToArray());
}

private void SetupTasks(List<Task> f_List)
{
    Task _task_TollGate = new Task(() =>
    {
        QueueEndpointCall();
    });
    f_List.Add(_task_TollGate);
}

private void QueueEndpointCall()
{
    Task<string> _t = g_httpclient_Main.GetStringAsync("http://www.google.com");
    Task.WaitAll(_t);
    Console.WriteLine(_t.Result);
}

The GetStringAsync was also similarly to the GetAsync call in my original snippet, seemingly not waiting when the Task.WaitAll was called from the main thread. So I grabbed the Task object from the GetStringAsync call and did a Task.WaitAll on that. Once I did this, then the code flow hit the Console.WriteLine after completing the GetStringAsync operation.

answered Jan 8 at 6:29

maegus

597 bronze badges

3 Comments

maegus Jan 8 at 6:32

Thanks to everyone who posted feedback / details for me to review

Panagiotis Kanavos Jan 8 at 11:23

The code is still buggy and uses bad naming conventions like g_, f_string_ or _t. Type prefixes are considered a bad practice in strongly typed languages since the late 1990s. How is EntryPoint called? If you have a console application, why not use async Task Main() and properly use await client.GetStringAsync ? There are other serious prolems too, like SecurityProtocol = SecurityProtocolType.Tls12 which prevents the use of TLS 1.3 instead of enabling TLS 1.2. Given the oldest .NET Framework version you'll find on Windows is 4.6.2, TLS 1.2 is on by default

Panagiotis Kanavos Jan 8 at 11:27

Also, despite the name, QueueEndpointCall doesn't queue any calls. You can easily call multiple URLs concurrently with await Parallel.ForEachAsync(urls,async (url,token)=>{ var content=await client.GetStringAsync(url); ...}.

Collectives™ on Stack Overflow

Task issue with Powershell and TaskScheduler

2 Answers 2

2 Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related