Convert a function to async task

Question

I have the following function:

 private void SendSMSs(List<SMS> smsList)
    {
        foreach (var sms in smsList)
        {
           SendSMS smsSend = new SendSMS(sms.message, sms.number, 0, SmsResponseCallback);
            Console.WriteLine("Sent a SMS to " + sms.number);
        }
    }

    /// <summary>
    /// Call back for sending a sms
    /// </summary>
    public void SmsResponseCallback(FSK_SendSMS.FSK_SendSMS.SMS_Result result)
    {
        Console.WriteLine("Succesfully sent a SMS to " + result.Destination + " with result: " + result.Result);
    }

Now my issue is that each sms waits till it gets a response from the recipient.

I want to create a task for each sms that needs to be sent. So that they can all be sent asynchronously.

The function SendSMSs does need to wait for the tasks to Finnish. It must return as soon as it can, and the sms will then be sent in their own time?

So how can I create a task which will start straight away and then I can move on and create the next.

You could do that by wrapping it in `Task.Run`. but... [think before you do](http://blogs.msdn.com/b/pfxteam/archive/2012/03/24/10287244.aspx) — Sriram Sakthivel, Feb 26 '14 at 12:29

Avishek · Answer 1 · 2014-02-27T04:48:07.377

0

You can do something like this using System.Threading;

private void SendSMSs(List<SMS> smsList)
{
    foreach(SMS sms in smsList)
    {
        Thread thread = new Thread(new ParameterizedThreadStart(SendOneSMS(sms)));
    }
}

private void SendOneSMS(SMS sms)
{
    SendSMS smsSend = new SendSMS(sms.message, sms.number, 0, SmsResponseCallback);
    Console.WriteLine("Sent a SMS to " + sms.number);
}

For doing the same job with Task using System.Threading.Tasks

foreach(SMS sms in smsList)
{
    var t = Task.Factory.StartNew(new Action(SendOneSMS(sms)));
}

edited Feb 27 '14 at 04:48

answered Feb 26 '14 at 12:33

Avishek

1,896
14
33

1

That's not what OP asks. He's asking for creating a `Task` not `Thread`. `Thread` **!=** `Task` – Sriram Sakthivel Feb 26 '14 at 12:36
I know. I provided a way to accomplish the requirement without using task. – Avishek Feb 26 '14 at 12:37
Unless this is a better / more efficient answer. I was just under the impression that the TPL (task parallel library) was the easiest/best/newest way to do this. I could be very wrong though – Zapnologica Feb 26 '14 at 12:38
Thread is a overkill for this. How'll you know when each sms is sent? – Sriram Sakthivel Feb 26 '14 at 12:38
@SriramSakthivel please notice the `SmsResponseCallback` – Avishek Feb 26 '14 at 12:39
O great thanks. So can I just put a task inside the foreach loop and it will destroy its self when its done? – Zapnologica Feb 26 '14 at 12:58
Task disposes itself automatically 99% of the time, except for some scenareo. refer http://stackoverflow.com/questions/3734280/is-it-considered-acceptable-to-not-call-dispose-on-a-tpl-task-object – Avishek Feb 26 '14 at 13:01
[Task.Factory.StartNew is dangerous](http://blog.stephencleary.com/2013/08/startnew-is-dangerous.html). Use Task.Start(). – CMircea Feb 26 '14 at 13:24
@CMircea, Steve is not recommending the use of `Task.Start()` on that blog post. In fact, I've never seen him do that. Quite the contrary. – Paulo Morgado Feb 26 '14 at 13:32
@PauloMorgado, I meant Task.Run, my apologies. – CMircea Feb 26 '14 at 13:33
Unless you are using .net framework lower than 4.5, you can use `Task.Run` – Avishek Feb 27 '14 at 04:49

score 0 · Answer 2 · answered Feb 26 '14 at 13:31

If the function that sends the SMS does not have an async alternative, you could use the TPL to start a task that will eventually block a thread to send an SMS:

private Task SendSMSs(List<SMS> smsList)
{
    return Task.WhenAll(from sms in smsList select SendSMS(sms));
}

private Task SendSMS(SMS sms)
{
    return Task.Run(() =>
    {
        SendSMS smsSend = new SendSMS(sms.message, sms.number, 0, SmsResponseCallback);
        Console.WriteLine("Sent a SMS to " + sms.number);
    });
}

score 0 · Answer 3 · answered Feb 27 '14 at 06:46

If you do this with a TaskCompletionSourceyou will get a more scalable solution as Task.Run uses up a thread. I haven't compiled this but you should be able to do something like this:

private void SendSMSs(List<SMS> smsList)
{
    var messagesSent = smsList.Select (s => SendSMS(s) ).ToArray();
    Task.WaitAll(messagesSent);
}

private Task<SMS_Result> SendSMS(SMS sms)
{
    var tcs = new TaskCompletionSource<SMS_Result>();

    SendSMS smsSend = new SendSMS(sms.message, sms.number, 0, result =>
    {
        tcs.SetResult = result;
        Console.WriteLine("Succesfully sent a SMS to " + result.Destination + " with result: " + result.Result);
    }); 

    Console.WriteLine("Sent a SMS to " + sms.number);

    return tcs.Task;
}

Convert a function to async task

3 Answers3