How to create an asynchronous method

Question

I have simple method in my C# app, it picks file from FTP server and parses it and stores the data in DB. I want it to be asynchronous, so that user perform other operations on App, once parsing is done he has to get message stating "Parsing is done".

I know it can achieved through asynchronous method call but I dont know how to do that can anybody help me please??

Erythritol

It's very simple. You create a delegate. Assign your function to it and then you make a async call. This article describe it very well (it also teach you what's a delegate). – Scone

Link didn't work for me?? – Atrioventricular

Just wanted to mention - there are 2 ways to perform asynchronous calls: with threads and with delegates. – Subtorrid

This article is unreadable... :s – Vories

Answer 1

You need to use delegates and the BeginInvoke method that they contain to run another method asynchronously. A the end of the method being run by the delegate, you can notify the user. For example:

class MyClass
{
    private delegate void SomeFunctionDelegate(int param1, bool param2);
    private SomeFunctionDelegate sfd;

    public MyClass()
    {
        sfd = new SomeFunctionDelegate(this.SomeFunction);
    }

    private void SomeFunction(int param1, bool param2)
    {
        // Do stuff

        // Notify user
    }

    public void GetData()
    {
        // Do stuff

        sfd.BeginInvoke(34, true, null, null);
    }
}

Read up at http://msdn.microsoft.com/en-us/library/2e08f6yc.aspx

Isomeric

Note that rather than declaring and using a SomeFunctionDelegate you can just use a Action<int,bool> and similarly a Func<Type1,Type2,ReturnType> for methods that are not void. – Isomeric

new Action<int, string>(MethodName).BeginInvoke(1, "text", null, null); – Bareback

this is Asynchronous delegates and not asynchronous methods.Asynchronous methods follow a similar protocol outwardly, but they exist to solve a much more difficult problem – Larger

@Royi: I think you are confused, this answer is nearly 4 years old and was before the time of async and such so is appropriate for the question. – Isomeric

@CallumRogers No I'm not. You are. read this i.sstatic.net/i3pH2.jpg and then this i.sstatic.net/BcX33.jpg they all taken from c# book from joe albahari v4. ( Fw4 , and has nothing to do with asunc) they are all from here albahari.com/threading/#_Asynchronous_delegates). you should Edit your answer. it is not a an asynchrouns method but delegate. – Larger

@Royi: I see what you mean - however just because the question is asking about asynchronous methods does not mean he's referring to the same thing that you are. OP is more requesting a way to call a method asynchronously and this is the correct answer. I have to say I've never really seen it called asynchronous methods - I think you mean asynchronous operation instead. – Isomeric

You mean "I thought you meant...". they are actually different things.The OP probably don't know that there are 2 subjects. he asked about asynchronous methods and you gave him an answer about Asynchronous delegates. – Larger

Answer 2

try this method

public static void RunAsynchronously(Action method, Action callback) {
    ThreadPool.QueueUserWorkItem(_ =>
    {
        try {
            method();
        } 
        catch (ThreadAbortException) { /* dont report on this */ } 
        catch (Exception ex) {
        }
        // note: this will not be called if the thread is aborted
        if (callback!= null) callback();
    });
}

Usage:

RunAsynchronously( () => { picks file from FTP server and parses it}, 
       () => { Console.WriteLine("Parsing is done"); } );

Calends

Answer 3

Any time you're doing something asynchronous, you're using a separate thread, either a new thread, or one taken from the thread pool. This means that anything you do asynchronously has to be very careful about interactions with other threads.

One way to do that is to place the code for the async thread (call it thread "A") along with all of its data into another class (call it class "A"). Make sure that thread "A" only accesses data in class "A". If thread "A" only touches class "A", and no other thread touches class "A"'s data, then there's one less problem:

public class MainClass
{
    private sealed class AsyncClass
    {
        private int _counter;
        private readonly int _maxCount;

        public AsyncClass(int maxCount) { _maxCount = maxCount; }

        public void Run()
        {
            while (_counter++ < _maxCount) { Thread.Sleep(1); }
            CompletionTime = DateTime.Now;
        }

        public DateTime CompletionTime { get; private set; }
    }

    private AsyncClass _asyncInstance;
    public void StartAsync()
    {
        var asyncDoneTime = DateTime.MinValue;
        _asyncInstance = new AsyncClass(10);
        Action asyncAction = _asyncInstance.Run;
        asyncAction.BeginInvoke(
            ar =>
                {
                    asyncAction.EndInvoke(ar);
                    asyncDoneTime = _asyncInstance.CompletionTime;
                }, null);
        Console.WriteLine("Async task ended at {0}", asyncDoneTime);
    }
}

Notice that the only part of AsyncClass that's touched from the outside is its public interface, and the only part of that which is data is CompletionTime. Note that this is only touched after the asynchronous task is complete. This means that nothing else can interfere with the tasks inner workings, and it can't interfere with anything else.

Corazoncorban

That "Async task ended at {0}" string isn't printed after the async task finishes... – Credenza

Plz correct your statement "Any time you're doing something asynchronous, you're using a separate thread". It is wrong. Check Asynchrony in C# 5.0 part Four: It's not magic – Marcela

It's always a separate thread, logically, even if, physically, the same thread can be reused. – Corazoncorban

Answer 4

Here are two links about threading in C#

• Threading in C#
• Multi-threading in .NET: Introduction and suggestions

I'd start to read about the BackgroundWorker class

Attired

Thanks for response ,is it possible to do it without threads, may be with delegates? – Erythritol

You can use a BeginInvoke(), but that invokes another thread, too. Really, have a look at the BackgroundWorker - it is easy to use and provides a notify when the job is done. – Attired

Answer 5

In Asp.Net I use a lot of static methods for jobs to be done. If its simply a job where I need no response or status, I do something simple like below. As you can see I can choose to call either ResizeImages or ResizeImagesAsync depending if I want to wait for it to finish or not

Code explanation: I use http://imageresizing.net/ to resize/crop images and the method SaveBlobPng is to store the images to Azure (cloud) but since that is irrelevant for this demo I didn't include that code. Its a good example of time consuming tasks though

private delegate void ResizeImagesDelegate(string tempuri, Dictionary<string, string> versions);
private static void ResizeImagesAsync(string tempuri, Dictionary<string, string> versions)
{
    ResizeImagesDelegate worker = new ResizeImagesDelegate(ResizeImages);
    worker.BeginInvoke(tempuri, versions, deletetemp, null, null);
}
private static void ResizeImages(string tempuri, Dictionary<string, string> versions)
{
    //the job, whatever it might be
    foreach (var item in versions)
    {
        var image = ImageBuilder.Current.Build(tempuri, new ResizeSettings(item.Value));
        SaveBlobPng(image, item.Key);
        image.Dispose();
    }
}

Or going for threading so you dont have to bother with Delegates

private static void ResizeImagesAsync(string tempuri, Dictionary<string, string> versions)
{
    Thread t = new Thread (() => ResizeImages(tempuri, versions, null, null));
    t.Start(); 
}

Sickle

Answer 6

ThreadPool.QueueUserWorkItem is the quickest way to get a process running on a different thread.

Be aware that UI objects have "thread affinity" and cannot be accessed from any thread other than the one that created them.

So, in addition to checking out the ThreadPool (or using the asynchronous programming model via delegates), you need to check out Dispatchers (wpf) or InvokeRequired (winforms).

Luisaluise

If anyone does need to access UI elements created on another thread (cross-thread exceptions), see this great post: #142503 – Isomeric

Answer 7

In the end you will have to use some sort of threading. The way it basically works is that you start a function with a new thread and it will run until the end of the function.

If you are using Windows Forms then a nice wrapper that they have for this is call the Background Worker. It allows you to work in the background with out locking up the UI form and even provides a way to communicate with the forms and provide progress update events.

Background Worker

Pentylenetetrazol

Answer 8

.NET got new keyword async for asonchrynous functions. You can start digging at learn.microsoft.com (async). The shortest general howto make function asonchrynous is to change function F:

Object F(Object args)
{
    ...
    return RESULT;
}

to something like this:

async Task<Object> FAsync(Object args)
{
    ...
    await RESULT_FROM_PROMISE;
    ...
    return RESULT;
}

The most important thing in above code is that when your code approach await keyword it return control to function that called FAsync and make other computation until promissed value has been returned and procede with rest of code in function FAsync.

Marni