I have been writing many posts about asynchronous operations and thought to write about asynchronous operations in WCF. In WCF, asynchronous operations can be implemented by using one of the three following methods:
- The event-based asynchronous pattern
- The IAsyncResult asynchronous pattern
- The task-based asynchronous pattern
Today I am going to explain how to implement asynchronous operations in WCF using each of these methods using some examples. In here I will not be covering the basics of WCF and I assume you all have some experience with programming WCF before. So I will start off with the event-based pattern.
1. The event-based asynchronous pattern
I have created a WCF Service Application and I have the default WCF service and it’s interface and I am modifying the service and it's contract as follows.
iService1.cs
[ServiceContract]
Service1.cs
public interface IService1
{
//event-based asynchronous pattern
[OperationContract]
string GetData(string message);
}
public class Service1 : IService1
{
public string GetData(string message)
{
Thread.Sleep(5000);
return message;
}
}
As you can see, In my service contract I have exposed a very simple method which will accept string and return a string. In my service I have it implemented and I have put a thread sleep, just for demonstration purposes.
Now I have my client console application and I am adding a Service Reference to this service. A thing to note here is I am enabling "Allow generation of asynchronous operations" and under that I am enabling "Generate asynchronous operations".
 |
| Add Service Reference |
 |
| Generate Asynchronous Operations |
Now let’s see the client side code.
class Program
{
static wsService1.Service1Client client1 = new wsService1.Service1Client();
static void Main(string[] args)
{
client1.GetDataCompleted += client_GetDataCompleted;
client1.GetDataAsync("event-based asynchronous pattern");
Console.WriteLine("Waiting for async operation...");
Console.ReadLine();
}
static void client_GetDataCompleted(object sender, wsService1.GetDataCompletedEventArgs e)
{
Console.WriteLine(e.Result.ToString());
}
}
In here what happens is first I am subscribing to the GetDataCompleted method. When the GetDataAsync Method has completed, client_GetDataCompleted event will be triggered. If you notice the control flow here, the operations in the server are still done synchronously, but operations in the client are done asynchronously.
Finally the output will be as follows, first it will print the “Waiting for async operation” and then it will print the message returned from the service.
Finally the output will be as follows, first it will print the “Waiting for async operation” and then it will print the message returned from the service.
 |
| Output |
2. The IAsyncResult asynchronous pattern
The second way of implementing WCF service operation in an asynchronous fashion is marking the <Begin> method with the AsyncPattern property set to true. In this case, the asynchronous operation is exposed with two additional methods;
We can further divide this IAsyncResult asynchronous pattern into two sub models. That is,- a method to start asynchronous operation (a method which has “Begin” pre fixed to original method name)
- a method to end asynchronous operation (a method which has “End” pre fixed to original method name).
- Client Side Asynchronous
- Both Side Asynchronous (Client & Server Side Asynchronous)
2.1. Client Side Asynchronous
For this Client-Side Asynchronous model, I will take the same WCF Service I got for demonstrating event-based asynchronous pattern.
[ServiceContract]
Service1.cspublic interface IService1
{
//event-based asynchronous pattern
[OperationContract]
string GetData(string message);
}
public class Service1 : IService1
{
{
public string GetData(string message)
{
Thread.Sleep(5000);
return message;
}
}
Now in my client console application I am using the same service reference.
class Program
{
static wsService1.Service1Client client1 = new wsService1.Service1Client();
static void Main(string[] args)
{
client1.BeginGetData("IAsyncResult asynchronous pattern (Client-Side)", new AsyncCallback(GetDataCallBack), null);
Console.WriteLine("Waiting for async operation...");
Console.ReadLine();
}
static void GetDataCallBack(IAsyncResult result)
{
Console.WriteLine(client1.EndGetData(result).ToString());
}
}
In here, I am calling the BeginGetData method which is generated by the proxy. It will always have it’s first parameter as the same parametes in the method I am calling asynchronously, plus two additional parameters. The second parameter is an AsyncCallback delegate that references a method to be called when the BeginGetData completes.The third parameter is a object which contain state about the asynchronous operation. So when my asynchronous BeginGetData completed, my callback method will be called. In my callback method I am calling the EndGetDate method (again which is generated by the proxy) to end the asynchronous operation and to retrieve the results.
Again the output will be as follows: first it will print the “Waiting for async operation” and then will print the message returned from the service.
 |
| Output |
2.2. Both Side Asynchronous
The Both-Side Asynchronous model of IAsyncResult asynchronous pattern is little bit different. In here we have both client side and server side operations asynchronous. If you have been reading the post carefully, when I am introducing the IAsyncResult asynchronous pattern, I have mentioned about setting AsyncPattern property to true to the begin method. And to above Client Side Asynchronous model of IAsyncResult asynchronous pattern, I didn’t do that. Now let’s take a look at the following model.
I am creating a new WCF service.
iService2.cs
[ServiceContract]
Service2.cspublic interface IService2
{
//IAsyncResult asynchronous pattern
[OperationContractAttribute(AsyncPattern = true)]
IAsyncResult BeginWorkerMethod(string message, AsyncCallback callback, object asyncState);
string EndWorkerMethod(IAsyncResult result);
}
public class Service2 : IService2
{
public IAsyncResult BeginWorkerMethod(string message, AsyncCallback callback, object asyncState)
{
var task = Task<string>.Factory.StartNew((res) => MyMethod(asyncState,message), asyncState);
return task.ContinueWith(res => callback(task));
}
public string EndWorkerMethod(IAsyncResult result)
{
return ((Task<string>)result).Result;
}
private string MyMethod(object asyncState,string message)
{
Thread.Sleep(5000);
return message;
}}
In my Service contract, I have defined two methods using the pattern BeginOperation and EndOperation. Please note that here I have applied AsyncPattern property to true only to the BeginWorkerMethod.
In the service, I have implemented these two methods. In here I have used Tasks for asynchronous operation. I have a callback method which will be called when the task is completed.
And in the client side, I have the following code.
class Program
{
static wsService2.Service2Client client2 = new wsService2.Service2Client();
static void Main(string[] args)
{
client2.BeginWorkerMethod("IAsyncResult asynchronous pattern (Server-Side)", new AsyncCallback(GetDataCallBack), null);
Console.WriteLine("Waiting for async operation...");
Console.ReadLine();
}
static void GetDataCallBack(IAsyncResult result)
{
Console.WriteLine(client2.EndWorkerMethod(result).ToString());
}
}
The output is the same: first it will print the “Waiting for async operation” and then it will print the message returned from the service.
 |
| Output |
3. The task-based asynchronous pattern
The task-based asynchronous pattern is the preferred way to implement asynchronous operations because it is the easiest and most straight forward. But the only thing is async/await was introduced with .NET framework 4.5. To demonstrate task-based asynchronous pattern, I am creating new WCF service.
iService3.cs
[ServiceContract]
public interface IService3
{
//task-based asynchronous pattern
[OperationContract]
Task<string> MyWorkerMethodAsync(string message);
}
public class Service3 : IService3
{
public async Task<string> MyWorkerMethodAsync(string message)
{
return await Task.Factory.StartNew(() =>; MyMethod(message));
}
private string MyMethod(string message)
{
Thread.Sleep(5000);
return message;
}
}
Now in my client console application when I am adding a Service Reference I am enabling "Allow generation of asynchronous operations" and under that I am enabling "Generate task-based operations".
 |
Generate Task-Based Operations
|
Now let’s see the client side code. Please make sure to change the Clients’ targeted framework to .NET Framework 4.5. In the client I have a async method and inside the async method, the await operator is applied to a task to suspend execution of the method until the task is completed.
class Program
{
static wsService3.Service3Client client3 = new wsService3.Service3Client();
static void Main(string[] args)
{
InvokeAsyncMethod("task-based asynchronous pattern");
Console.WriteLine("Waiting for async operation...");
Console.ReadLine();
}
static async void InvokeAsyncMethod(string message)
{
Console.WriteLine(await client3.MyWorkerMethodAsync(message));
}
}
The output is the same: first it will print the “Waiting for async operation” and then will print the message returned from the service.
 |
| Output |
And that's basics of asynchronous operations in WCF. I am attaching the sample code to my sky drive, you can download and play around.
Hope you got something out of this post. As always appreciate your feedback.
Hope you got something out of this post. As always appreciate your feedback.
Happy Coding.
Regards,
Jaliya
I would like to use the async keyword in the implementation of a WCF operation, but only for the purposes of optimizing thread use on the server side -- that is, I don't need the operation to be asynchronous on the client side. So, on the server side I want something like:
ReplyDelete[OperationContract]
public Task FiddleString(string input)
{
return await FiddleStringAsync(input);
}
but on the client I just want to call:
proxy.FiddleString("foo");
Does WCF support this? (i.e. does the WCF infrastructure see that operation implementation is async and use the returned task's Awaiter to send the result back to the client when it is ready?)
Thanks!
Terry.
Usually your service will be hosted in a multithreaded context (operations run on thread pool threads). But your client will usually be hosted in a GUI context (single-threaded apartment).
DeleteThus, you are MOST in need of async calls on the client side.
The main motivation for async-await is to make it easy to run some code async but continue back on the UI thread (to update the interface with results, for example).
A notable exception to this is when the service is running in the same context as the client (or when the service is hosted in another GUI application). Then you want the service to perform work in the background. And you want the client to interact with the service in the background.
You may also have situations where a service needs to perform several tasks in parallel, or where multiple calls to other services are required.
But the bottom line is, you will almost ALWAYS want the client to be responsive while any significant work is being performed in the background.
Look async and await in frame 4.5
ReplyDeleteBe carefull with aggregate exception for Task, it eats a lot from your CPU and RAM. In IIS it lead to hit the application pool to rapid fail protection limit
ReplyDeleteLooks like you have some code formatting issues in the Service3.cs sample above.
ReplyDeletedon't need the operation to be asynchronous on the client side.
ReplyDelete