Question

Suppose I have the following class:

Public class FooBar
{

   List<Items> _items = new List<Items>();

   public List<Items> FetchItems(int parentItemId)
   {

     FetchSingleItem(int itemId);

     return _items
   }

   private void FetchSingleItem(int itemId)
   {

   Uri url = new Uri(String.Format("http://SomeURL/{0}.xml", itemId);
   HttpWebRequest webRequest = (HttpWebRequest)HttpWebRequest.Create(url);

   webRequest.BeginGetResponse(ReceiveResponseCallback, webRequest);

   }

   void ReceiveResponseCallback(IAsyncResult result)
   {

     // End the call and extract the XML from the response and add item to list

     _items.Add(itemFromXMLResponse);

     // If this item is linked to another item then fetch that item 


     if (anotherItemIdExists == true)
     {
        FetchSingleItem(anotherItemId);
     }


   }

}

There could be any number of linked items that I will only know about at runtime.

What I want to do is make the initial call to FetchSingleItem and then wait until all calls have completed then return List<Items> to the calling code.

Could someone point me in the right direction? I more than happy to refactor the whole thing if need be (which I suspect will be the case!)

Answer 1

Getting the hang of asynchronous coding is not easy especially when there is some sequential dependency between one operation and the next. This is the exact sort of problem that I wrote the AsyncOperationService to handle, its a cunningly short bit of code.

First a little light reading for you: Simple Asynchronous Operation Runner – Part 2. By all means read part 1 but its a bit heavier than I had intended. All you really need is the AsyncOperationService code from it.

Now in your case you would convert your fetch code to something like the following.

 private IEnumerable<AsyncOperation> FetchItems(int startId)
 {
     XDocument itemDoc = null;
     int currentId = startId;

     while (currentID != 0)
     {
        yield return DownloadString(new Uri(String.Format("http://SomeURL/{0}.xml", currentId), UriKind.Absolute),
             itemXml => itemDoc = XDocument.Parse(itemXml) );

        // Do stuff with itemDoc like creating your item and placing it in the list.

        // Assign the next linked ID to currentId or if no other items assign 0

     }
 }

Note the blog also has an implementation of DownloadString which in turn uses WebClient which simplifies things. However the principles still apply if for some reason you must stick with HttpWebRequest. (Let me know if you are having trouble creating an AsyncOperation for this)

You would then use this code like this:-

int startId = GetSomeIDToStartWith();
Foo myFoo = new Foo();

myFoo.FetchItems(startId).Run((err) =>
{
    // Clear IsBusy
    if (err == null)
    {
        // All items are now fetched continue doing stuff here.

    }
    else
    {
        // "Oops something bad happened" code here
    }
}
// Set IsBusy 

Note that the call to Run is asynchronous, code execution will appear to jump past it before all the items are fetched. If the UI is useless to the user or even dangerous then you need to block it in a friendly way. The best way (IMO) to do this is with the BusyIndicator control from the toolkit, setting its IsBusy property after the call to Run and clearing it in the Run callback.