With the WCF thing, basically I was just trying to illustrate a situation where I'm making an asynchronous call to some service. It might be a standard ASP.NET web service, it might be a WCF service... or even just a delegate.
Say you have a WCF service that is a calculator - the stereotypical example. It's got a contract that looks like this:
[ServiceContract]
public interface ICalculator{
[OperationContract]
int Add(int a, int b);
}
You implement the service.
public class CalculatorService : ICalculator{
public int Add(int a, int b){
return a + b;
}
}
Then you create a client app for the service. Maybe a console app. In Visual Studio, you right-click the project and select "Add Service Reference..." Enter the URL to your service and it pops up, just like classic "Add Web Reference." Select the service and before clicking "OK" set it to "Generate async operations." (You can also do this with the svcutil.exe utility, using the /async option. I think that's what VS is doing under the covers.)
In your client app you now have a proxy with three methods of interest on it:
- public int Add(int a, int b) - To call the service's Add method synchronously.
- public IAsyncResult BeginAdd(int a, int b, AsyncCallback callback, object state) - To start an async call to the Add method.
- public int EndAdd(IAsyncResult result) - To end the async call to the Add method and get the result.
In your client app, you:
- New up a proxy to your service.
- Create an AsyncCallback delegate that does something like writing the result of the addition operation out to the console.
- Call the proxy.BeginAdd method. Pass it your AsyncCallback delegate so that work will get done when the async operation is complete. Store the returned IAsyncResult for later.
- Do some work. Doesn't matter what. You're doing work while the service is doing some addition for you. The callback delegate will be executed whenever the operation is finished.
- Wait on the IAsyncResult.AsyncWaitHandle to ensure you don't progress until the operation is done.
- End the client program.
Again, the idea here is that if I don't actually want to call the service, I can mock the call to "BeginAdd" just fine in step 3, but my callback delegate will never be called in step 4 because there's no real async operation happening, and in step 5 I have to mock the IAsyncResult and just set the waithandle so it won't block the program.
This is the same pattern as
calling a delegate asynchronously.
What I'd love to see is something that allows me to mock an async call so that the callback actually does get called and the IAsyncResult is real. Maybe I could specify some sort of duration to wait for the operation to return so I can simulate what it's like to asynchronously call a long-running service operation.
If you still need me to craft up an example, I can, but I wouldn't get stuck on the "WCF" part. I'm more interested in the mocking of an async call to pretty much anything - a service, a delegate, or whatever.
