Question

I’ve run into quite an awkward predicament in a project at work. We need to create users across 4 or 5 different services, and have set it up in such a way that if one fails, they all fail. They’re encapsulated within a transaction scope block.

One of the services we need to add users to requires telnetting in, and fudging some data. There are other ways to do it (that cost money) but for now that’s what we’re stuck with. Adding one user takes approximately 3 minutes. We’re going to work on getting that down significantly as can be imagined but that’s not really the point. This call is asynchronous and kind of has to be to work correctly. The punchline is, there can only be a maximum of 10 connections to the service.

Our project is being set up to create users in a batch. So potentially 50 users created at a time. This presents a problem when only 10 connections can be made via telnet, and a processed user isn’t likely to take very long other than the telnet service. I now need to synchronise this process so the rest can’t continue until it has finished.

We’re using callbacks and delegates with asynchronous calls to implement the functionality. What would be the best way of encapsulating the asynchronous portion, and not continuing until it’s completed?

Should we set up a loop that only terminates when the call is finished? Is there something in the Threading library that could help? I’ve never worked with threads before so this will be a first for me. What tools are there to help with this problem?

EDIT:

If I use the BeginInvoke / EndInvoke pattern, will asynch calls within the first delegate honour the begin/end also?

Example:

public void dele1(string message) {     Console.Write(message);     delegate2 del2 = new delegate2;     del2();     Console.Write('End of Delegate 2'); }  public void dele2() {     // Long Processing     Console.Write('Delegate 2'); }  public delegate void delegate1(String message); public delegate void delegate2();  delegate1 del1 = new delegate1(dele1); del1('Delegate 1').BeginInvoke; del1().EndInvoke; Console.Write('End of Delegate 1'); 

// Expected Output (End Invoke waits until Delegate 2 is finished):

Delegate 1 End of Delegate 2 Delegate 2 End of Delegate 1 

// Or (End Invoke only waits for delegate 1 to finish but not any internal delegate calls):

Delegate 1 End of Delegate 2 End of Delegate 1 Delegate 2 

Will end invoke wait until the second delegate finishes processing also? Or will I need to use the invoke patterns on all delegate calls?

Answer 1

You could indeed use monitors, semaphores, or you could even spin wait until your asynchronous method call(s) is done.

But you can get this for free too. If you call EndInvoke() on a delegate that was previously started with BeginInvoke(), you block until the asynchronous work is done.

Not sure if this helps because you have to be using this asynchronous pattern. If it does, you get Asynchronous execution (and conversion from Asynchronous back to synchronous calls) for free.

Check out Calling Synchronous Methods Asynchronously on MSDN for more info on this pattern.

I hope this helps!