CODEWITHSUNDEEP
c#asp.net.netc#-4.0asynchronous
Jasmine
Jasmine

Reputation: 5326

How to handle this asynchronous programming scenario in C#

I just had an interview 5 minutes back. I was given this scenario and he asked me the question on how to handle this in C# 1.0 or 2.0. He said there is a basic feature to handle this, I wasn't sure. Can somebody please help :(

Question:

There are 2 text boxes in Winform application and a button. One text box takes input value and when button is clicked, it process input in server which takes hell lot of time and finally displays the result in another textbox. As it takes very long time in server, the UI shouldn't be interupted, how do you handle this scenario he asked me :(

Answer I gave:

I told multithreading and said about async and await. He was expecting a simple way of handling this in C# 2.0 thing. I was guessing about asynchronous delegates. He wasn't convinced. Please someone explain me with little understandble code :)

Upvotes: 1

Views: 763

Answers (2)

Lee
Lee

Reputation: 144206

In .Net 2 winform applications, the simplest solution is to use a BackgroundWorker. Its events are raised on the UI thread so you don't need to do any marshalling yourself.

The usual pattern looks like:

BackgroundWorker bg = new BackgroundWorker();
bg.DoWork += delegate(object sender, DoWorkEventArgs e) {
    try {
        e.Result = server.LongRunningOperation();
    }
    catch(Exception ex) {
        e.Error = ex;
    }
};

bg.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e) {
    //update UI
};

bg.RunWorkerAsync();

Upvotes: 0

DGibbs
DGibbs

Reputation: 14618

You would run the long running process in a separate thread to the UI to prevent it hanging, perhaps a BackgroundWorker would be used for example: -

bgWorker.RunWorkerAsync([DATA TO PROCESS])//Passing in data to operate on

private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
      MyObject obj = (MyObject)sender;

      //
      // Do some work with the data on the server
      // 

      // Report on progess, is it done?
      bgWorker.ReportProgress();
}

You could also have a work complete method

 private void bgWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 {
       //Work is complete, notify user
 }

You could also use a ThreadPool, which requires a little more set up but i find is more flexible. For example: -

ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), [DATA TO PROCESS]);
Interlocked.Increment(ref workItems);

workItems would be a count of the number of items left to process, this could be used to keep track of whether the task is complete or not. We then define a DoWork method where we process the data and decrement our workItems counter. Once an item has been processed, we report progress via delegates such as: -

  private delegate void ThreadDone(MyObject obj);
  private delegate void TaskDone();

  public void DoWork(object sender)
   {
        MyObject obj = (MyObject)sender;

        this.Invoke(new ThreadDone(ReportProgress), result);
        Interlocked.Decrement(ref workItems);

        if (workItems == 0)
        {
            this.Invoke(new TaskDone(WorkComplete));
        }
    }

Report progress might look like this: -

private void ReportProgress(MyObject obj)
{
    if (workItems >= 0)
    {
        //Job isn't complete, report progress             
    }
}

private void WorkComplete()
{

}

Upvotes: 1

Related Questions