We Keep Coding

Using Parallel ForEach to POST in API and single Handle each Response

I would like to know if the code I produced is good practice and does not produce leaks, I have more than 7000 objects Participant which I will push individually and Handle the Response to save the "external" id in our database. First I use the Parallel ForEach on the list pPartcipant:
Parallel.ForEach(pParticipant, participant =>
{
try
{
//Create
if (participant.id == null)
{
ExecuteRequestCreate(res, participant);
}
else
{//Update
ExecuteRequestUpdate(res, participant);
}
}
catch (Exception ex)
{
LogHelper.Log("Fail Parallel ", ex);
}
});
Then I do a classic (not async request), but after I need to "handle" the response (print in the console, save in a text file in async mode, and Update in my database)
private async void ExecuteRequestCreate(Uri pRes, ParticipantDo pParticipant)
{
try
{
var request = SetRequest(pParticipant);
//lTaskAll.Add(Task.Run(() => { ExecuteAll(request, pRes, pParticipant); }));
//Task.Run(() => ExecuteAll(request, pRes, pParticipant));
var result = RestExecute(request, pRes);
await HandleResult(result, pParticipant);
//lTaskHandle.Add(Task.Run(() => { HandleResult(result, pParticipant); }));
}
catch (Exception e)
{
lTaskLog.Add(LogHelper.Log(e.Message + " " + e.InnerException));
}
}
Should I run a new task for handeling the result (as commented) ? Will it improve the performance ?
In comment you can see that I created a list of tasks so I can wait all at the end (tasklog is all my task to write in a textfile) :
int nbtask = lTaskHandle.Count;
try
{
Task.WhenAll(lTaskHandle).Wait();
Task.WhenAll(lTaskLog).Wait();
}
catch (Exception ex)
{
LogHelper.Log("Fail on API calls tasks", ex);
}
I don't have any interface it is a console program.

I would like to know if the code I produced is good practice
No; you should avoid async void and also avoid Parallel for async work.
Here's a similar top-level method that uses asynchronous concurrency instead of Parallel:
var tasks = pParticipant
.Select(participant =>
{
try
{
//Create
if (participant.id == null)
{
await ExecuteRequestCreateAsync(res, participant);
}
else
{//Update
await ExecuteRequestUpdateAsync(res, participant);
}
}
catch (Exception ex)
{
LogHelper.Log("Fail Parallel ", ex);
}
})
.ToList();
await Task.WhenAll(tasks);
And your work methods should be async Task instead of async void:
private async Task ExecuteRequestCreateAsync(Uri pRes, ParticipantDo pParticipant)
{
try
{
var request = SetRequest(pParticipant);
var result = await RestExecuteAsync(request, pRes);
await HandleResult(result, pParticipant);
}
catch (Exception e)
{
LogHelper.Log(e.Message + " " + e.InnerException);
}
}

How to get handle of an awaitable Task?

I am a newbie in Tasks and still learning this topic so be gentle with me (I think I have some fundamental mess-ups with my below code...)
Please look at the below exercise which will help me describe my question:
I have a simple "MyService" class which has a "Do_CPU_Intensive_Job" method called by the "Run" method. My purpose is to be able to run several instances of the "Do_CPU_Intensive_Job" method (which itself run on a different thread than the UI as its CPU bound), sometimes synchronously and sometimes asynchronously.
In other words, assuming I have 2 instances of MyService, sometimes I want these 2 methods running together and sometimes not.
class MyService
{
private bool async;
private string name;
private CancellationTokenSource tokenSource;
private CancellationToken token;
private bool isRunning = false;
private Task myTask = null;
public MyService(string name, bool async)
{
this.name = name;
this.async = async;
}
public string Name { get { return name; } }
public bool IsRunning { get { return isRunning; } }
public async Task Run ()
{
isRunning = true;
tokenSource = new CancellationTokenSource();
token = tokenSource.Token;
if (async)
myTask = Do_CPU_Intensive_Job();
else
await Do_CPU_Intensive_Job(); // I cannot do myTask = await Do_CPU_Intensive_Job(); so how can the "Stop" method wait for it??
}
public async Task Stop ()
{
tokenSource.Cancel();
if (myTask != null)
await myTask;
isRunning = false;
}
private async Task Do_CPU_Intensive_Job ()
{
Console.WriteLine("doing some heavy job for Task " + name);
int i = 0;
while (!token.IsCancellationRequested)
{
Console.WriteLine("Task: " + name + " - " + i);
await Task.Delay(1000);
i++;
}
Console.WriteLine("Task " + name + " not yet completed! I need to do some cleanups");
await Task.Delay(2000); //simulating cleanups
Console.WriteLine("Task " + name + " - CPU intensive and cleanups done!");
}
}
So, I have the below GUI which which works well but only if the 2 instances are running asynchronously. "works well" means that when stopping the tasks, it stops nicely by running entire "Do_CPU_Intensive_Job" method. hence the last message will be from the GUI ("Both tasks are completed...now doing some other stuff"). So far so good.
public partial class Form1 : Form
{
List<MyService> list = null;
MyService ms1 = null;
MyService ms2 = null;
public Form1()
{
InitializeComponent();
list = new List<MyService>();
ms1 = new MyService("task 1", true);
ms2 = new MyService("task 2", true);
list.Add(ms1);
list.Add(ms2);
}
private async void button1_Click(object sender, EventArgs e)
{
foreach (MyService item in list)
await item.Run();
}
private async void button2_Click(object sender, EventArgs e)
{
foreach (MyService item in list)
{
if (item.IsRunning)
{
await item.Stop();
Console.WriteLine("Done stopping Task: " + item.Name);
}
}
//now ready to do some other stuff
Console.WriteLine("Both tasks are completed...now doing some other stuff");
}
}
Problem starts when the 2 instances are not running simultaneously. In that case, I get the "Both tasks are completed...now doing some other stuff" from the GUI before "Do_CPU_Intensive_Job" is really completed...
ms1 = new MyService("task 1", false);
ms2 = new MyService("task 2", false);
this is not happening when both tasks are running together because I have the handle (myTask) when running asynchronously which I dont when running synchronously.
await Do_CPU_Intensive_Job(); // I cannot do myTask = await Do_CPU_Intensive_Job(); so how can the "Stop" method wait for it??
Thanks, all

I spent some time hammering out the code to a point that I think it is doing what is expected.
The first problem I found is that you can't just pass the cancellation token into your method, you need to relate it to the task(s) that are to be cancelled. Unfortunately I could not find a way to do this directly on an async method but have a look at the MyService class here for how I was able to do this.
class MyService
{
private bool async;
private string name;
private CancellationTokenSource tokenSource;
private bool isRunning = false;
private Task myTask = null;
public MyService(string name, bool async)
{
this.name = name;
this.async = async;
}
public string Name { get { return name; } }
public bool IsRunning { get { return isRunning; } }
public async Task Run()
{
isRunning = true;
tokenSource = new CancellationTokenSource();
myTask = Task.Run(() => Do_CPU_Intensive_Job(tokenSource.Token), tokenSource.Token);
if (!async)
await myTask;
}
public async Task Stop()
{
tokenSource.Cancel();
if (myTask != null)
await myTask;
isRunning = false;
}
private void Do_CPU_Intensive_Job(CancellationToken token)
{
Console.WriteLine("doing some heavy job for Task " + name);
int i = 0;
while (!token.IsCancellationRequested)
{
Console.WriteLine("Task: " + name + " - " + i);
Thread.Sleep(1000);
i++;
}
Console.WriteLine("Task " + name + " not yet completed! I need to do some cleanups");
Thread.Sleep(1000);
Console.WriteLine("Task " + name + " - CPU intensive and cleanups done!");
}
}
The Run method is now using Task.Run to call Do_CPU_Intensive_Job and if you note I am passing the token to both the work method and to the Task.Run call. The latter is what links the token to that Task/Thread and the former is what allows us to watch for the cancellation request.
The final piece is how we call Run on the service instances, by calling await on a Task or async method the thread is being released but the remainder of the code in the method is extracted and will not be run until the awaited task completes.
I was just using a unit test in order to work on the code rather than a button but the premise should be the same, but here is how I was able to run the tasks in synchronous mode and still be able to call stop on them.
var service1 = new MyService("task 1", false);
var service2 = new MyService("task 2", false);
service1.Run(); //Execution immediately moves to next line
service2.Run(); // Same here
await service1.Stop(); //Execution will halt here until task one has fully stopped so task 2 actually continues running
await service2.Stop();

How to delete current task in pool threads?

I have this event handler in asp.net page:
protected void SetDescPoint(object sender, EventArgs e)
{
try
{
ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(foo));
}
catch (Exception)
{ }
}
private void foo(object a)
{
try
{
System.Diagnostics.Debug.WriteLine("Start - " + DateTime.Now.ToString("h:mm:ss tt"));
TimeSpan minutes = TimeSpan.FromMinutes(10);
System.Threading.Thread.Sleep(minutes);
string path = UniquePath();
File.Delete(path);
System.Diagnostics.Debug.WriteLine("Deleted - " + DateTime.Now.ToString("h:mm:ss tt"));
}
catch (Exception ex)
{
Debug.WriteLine("EXCEPTION - " + ex.Message);
}
}
SetDescPoint is event handler and fired in response to client event.As you can see the function foo has Thread.Sleep(10minutes) there is might be situation when event handler fired in time interval less than 10 minutes, so in that situation I need to delete current task(foo()) in pool threads.
Any Idea how can I implement it?

Rewrite your code to use Task.Delay. This has two benefits: you're not holding up a thread anymore (as Task.Delay uses a timer internally), and you can use a cancellation token to cancel the wait:
protected CancellationTokenSource CancellationToken { get; private set; }
protected void SetDescPoint(object sender, EventArgs e)
{
try
{
Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
this.CancellationToken = new CancellationTokenSource();
Task.Run(() => foo(this.CancellationToken.Token), this.CancellationToken.Token);
}
catch (Exception)
{ }
}
private async Task foo(CancellationToken token)
{
try
{
System.Diagnostics.Debug.WriteLine("Start - " + DateTime.Now.ToString("h:mm:ss tt"));
TimeSpan minutes = TimeSpan.FromMinutes(10);
await Task.Delay(minutes, token);
string path = UniquePath();
File.Delete(path);
System.Diagnostics.Debug.WriteLine("Deleted - " + DateTime.Now.ToString("h:mm:ss tt"));
}
catch (Exception ex)
{
Debug.WriteLine("EXCEPTION - " + ex.Message);
}
}
Whenever you want to cancel your task, just call CancellationToken.Cancel()

A rather simplified way of dealing with this would be to keep track of a CancellationTokenSource for each path your create (I'm not sure if there a multiple paths or a simple path, but just in case), and then look it up once the event fires again.
Using this with Task.Delay, which asynchronously yields control in a non-blocking fashion, can achieve what you want:
private ConcurrentDictionary<string, CancellationTokenSource> pathsToTokens =
new ConcurrentDictionary<string, CancellationTokenSource>();
protected async void SetDescPointAsync(object sender, EventArgs e)
{
CancellationTokenSource existingTokenSource;
var path = UniquePath();
if (pathsToTokens.TryGetValue(path, out existingTokenSource))
{
existingTokenSource.Cancel();
}
var cancellationTokenSource = new CancellationTokenSource();
pathsToTokens.AddOrUpdate(path, cancellationTokenSource,
(pathToFile, token) => cancellationTokenSource);
try
{
await Task.Delay(TimeSpan.FromMinutes(10), cancellationTokenSource.Token)
.ConfigureAwait(false);
}
catch (TaskCanceledException tce)
{
// Token was cancelled, do something?
}
Foo(path);
pathsToTokens.TryRemove(path, out cancellationTokenSource);
}
private void Foo(string path)
{
try
{
File.Delete(path);
Debug.WriteLine("Deleted - " + DateTime.Now.ToString("h:mm:ss tt"));
}
catch (Exception ex)
{
Debug.WriteLine("EXCEPTION - " + ex.Message);
}
}
What happens with this code is that for each path you create, you allocate a new CancellationTokenSource. Every time the event is triggered, you check for an existing token. If it is in place, that means the event still hasn't finished, and you want to cancel it. Then, you asynchronously wait the amount of time you need. Note that Task.Delay is wrapped in a try-catch as calling CancellationTokenSource.Cancel will cause it to throw an exception once completed.

C# TAP async Multiple enqueue Delay then dequeue all

I have a system where a method is called with an object and the database is written with a different object with a list of the first .
Currently :
private async Task SaveAMessage(Messsage message)
{
var messages = new List<Message>();
messages.Add(message);
var envelope = new Envelope();
envelope.messages = messages;
await _db.Save(envelope);
}
But I can only run _db.Save every 1 second.
What is the TAP way of saying: Add this item to the list and then save them all together after 1 second. Below I have some fake code that expresses what I wish I could write.
Javascript-y Pseudo Code:
private List<Message> messages = new List<Message>();
private int? valueCheckTimer;
private async Task SaveAMessage(Messsage message)
{
messages.Add(message);
if (valueCheckTimer) {
return;
}
valueCheckTimer = setTimeout(function () {
var envelope = new Envelope();
envelope.messages = messages;
await _db.Save(envelope);
messages.Clear();
},1000);
}
How do I write C# code that acts the way the pseudo-code works?

You can actually do this with just one small really simple change. Add a WhenAll to SaveAMessage to await both Save as well as a call to Task.Delay:
private async Task SaveAMessage(Messsage message)
{
var messages = new List<Message>();
messages.Add(message);
var envelope = new Envelope();
envelope.messages = messages;
await Task.WhenAll(_db.Save(envelope), Task.Delay(1000));
}
Now you can just loop through all of your calls to SaveAMessage, awaiting them all, and you can be sure that it waits until the previous save is done and that at least a second has passed before continuing.
If you sometimes don't need to wait a full second when using SaveAMessage elsewhere, then simply pull this change out and have whatever code you're using to save all of your messages await the Task.Dealy call.

Try this piece of c# code (run as ConsoleApp):
namespace ConsoleApplication1
{
public class Program
{
private static async Task<string> SaveAMessage(string message)
{
var messages = new List<string>();
messages.Add(message);
return await save(messages);
}
private static Task<string> save(List<string> msg)
{
Task<string> task = Task.Factory.StartNew<string>(() =>
{
Console.WriteLine("Message " + msg[0] + " received...");
Console.WriteLine("Message " + msg[0] + " running...");
Thread.Sleep(3000);
return "Message " + msg[0] + " finally return.";
});
return task;
}
public static void Main(string[] args)
{
Task<string> first = SaveAMessage("Msg1");
first.ContinueWith(x => Console.WriteLine("Print " + x.Result));
Task<string> second = SaveAMessage("Msg2");
second.ContinueWith(x => Console.WriteLine("Print " + x.Result));
Task<string> third = SaveAMessage("Msg3");
third.ContinueWith(x => Console.WriteLine("Print " + x.Result));
Task<string> fourth = SaveAMessage("Msg4");
fourth.ContinueWith(x => Console.WriteLine("Print " + x.Result));
Task<string> fifth = SaveAMessage("Msg5");
fifth.ContinueWith(x => Console.WriteLine("Print " + x.Result));
Console.ReadKey();
}
}
}

await async lambda in ActionBlock

I have a class Receiver with an ActionBlock:
public class Receiver<T> : IReceiver<T>
{
private ActionBlock<T> _receiver;
public Task<bool> Send(T item)
{
if(_receiver!=null)
return _receiver.SendAsync(item);
//Do some other stuff her
}
public void Register (Func<T, Task> receiver)
{
_receiver = new ActionBlock<T> (receiver);
}
//...
}
The Register-Action for the ActionBlock is a async-Method with a await-Statement:
private static async Task Writer(int num)
{
Console.WriteLine("start " + num);
await Task.Delay(500);
Console.WriteLine("end " + num);
}
Now what i want to do is to wait synchronously (if a condition is set) until the action method is finished to get an exclusive behavior:
var receiver = new Receiver<int>();
receiver.Register((Func<int, Task) Writer);
receiver.Send(5).Wait(); //does not wait the action-await here!
The Problem is when the "await Task.Delay(500);" statement is executed, the "receiver.Post(5).Wait();" does not wait anymore.
I have tried several variants (TaskCompletionSource, ContinueWith, ...) but it does not work.
Has anyone an idea how to solve the problem?

ActionBlock by default will enforce exclusive behavior (only one item is processed at a time). If you mean something else by "exclusive behavior", you can use TaskCompletionSource to notify your sender when the action is complete:
... use ActionBlock<Tuple<int, TaskCompletionSource<object>>> and Receiver<Tuple<int, TaskCompletionSource<object>>>
var receiver = new Receiver<Tuple<int, TaskCompletionSource<object>>>();
receiver.Register((Func<Tuple<int, TaskCompletionSource<object>>, Task) Writer);
var tcs = new TaskCompletionSource<object>();
receiver.Send(Tuple.Create(5, tcs));
tcs.Task.Wait(); // if you must
private static async Task Writer(int num, TaskCompletionSource<object> tcs)
{
Console.WriteLine("start " + num);
await Task.Delay(500);
Console.WriteLine("end " + num);
tcs.SetResult(null);
}
Alternatively, you could use AsyncLock (included in my AsyncEx library):
private static AsyncLock mutex = new AsyncLock();
private static async Task Writer(int num)
{
using (await mutex.LockAsync())
{
Console.WriteLine("start " + num);
await Task.Delay(500);
Console.WriteLine("end " + num);
}
}