How to handle this asynchronous programming scenario in C#

Question

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 :)

DGibbs · Accepted Answer · 2013-03-12 13:16:38Z

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()
{

}

Hi DGibbs, thank you so much for helping me through, it helps me a lot. I will explore more on to this. Cheers :)

Lee · Accepted Answer · 2013-03-12 13:19:03Z

0

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();

edited Mar 12, 2013 at 13:19

answered Mar 12, 2013 at 13:06

Lee

145k20 gold badges243 silver badges292 bronze badges

1 Comment

Jasmine Over a year ago

Thank you so much Lee, it helps me, I think this is the thing he was expecting, damn I didn't say this :(. I will explore this concept today itself :) Thank you again :) Cheers

Collectives™ on Stack Overflow

How to handle this asynchronous programming scenario in C#

2 Answers 2

1 Comment

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related