在双工WCF服务的客户端中使用基于任务的异步模式时出错

Question

I develop download manager application that consists of two parts: 1) Duplex WCF service that performs downloading and sends downloading status data to client in real-time. 2) WPF Client that receives downloading status data from the service and displays in DataGrid. In my duplex WCF service there is a callback interface

 [ServiceContract(CallbackContract = typeof(IDownloadManagerServiceCalback))] 
 public interface IDownloadManagerServiceCalback
 {
     /// <summary>
     /// Returns changed downloading status to client.
     /// </summary>
     /// <returns>Downloading which has changed status</returns>
     [OperationContract(IsOneWay = true)]
     void UpdateSelectedDownload(DownloadStatus p_SelectedDownload);
 }

On the client side I implement this interface:

 class CallbackHandler : IDownloadManagerServiceCallback
 {
     /// <summary>
     /// "Download status changed" event.
     /// </summary>
     public event EventHandler<DownloadStatusChangedEventArgs> DownloadStatusChanged;

     public async Task UpdateSelectedDownload(DownloadStatus p_UpdatedDownload)
     {
         await Task.Run(() =>
         {
             // If handler was subscribed to event:
             if (DownloadStatusChanged != null)
             {
                  DownloadStatus updatedDownload = p_UpdatedDownload;
                  DownloadStatusChangedEventArgs updatedDownloadArgs = new DownloadStatusChangedEventArgs();
                  updatedDownloadArgs.Download = updatedDownload;
                  DownloadStatusChanged(this, updatedDownloadArgs);
             }
         });
    }
 }

When I build the solution I have the following error (text of error message i translate from Russian to English because my Visual Studio 2013 is Russianize):

DownloadManager_Client.CallbackHandler doesn't implement member "DownloadManager_Client.DownloadManager_ServiceReference.IDownloadManagerServiceCallback.UpdateSelectedDownload(DownloadManager_Client.DownloadManager_ServiceReference.DownloadStatus)". "DownloadManager_Client.CallbackHandler.UpdateSelectedDownload(DownloadManager_Client.DownloadManager_ServiceReference.DownloadStatus)" can't be implemented "DownloadManager_Client.DownloadManager_ServiceReference.IDownloadManagerServiceCallback.UpdateSelectedDownload(DownloadManager_Client.DownloadManager_ServiceReference.DownloadStatus)", because it doesn't contain appropriate returned “void” type.

Here DownloadManager_Client is the name of WPF client project, DownloadManager_ServiceReference is the name of service reference to WCF service in the client project. How can I correct this error?

Answer 1

The interface should be defined as returning Task not void since your implementation is an async method returning a Task .

EDIT: You are in a pickle because you want to use async which require a Task to be returned however your method is marked as IsOneWay = true - you can't have both. Either IsOneWay = false and keep the async nature or keep one-way but remove the async.

Example 1 - Async method

 [ServiceContract(CallbackContract = typeof(IDownloadManagerServiceCalback))] 
 public interface IDownloadManagerServiceCalback
 {
     /// <summary>
     /// Returns changed downloading status to client.
     /// </summary>
     /// <returns>Downloading which has changed status</returns>
     [OperationContract(IsOneWay = false)]
     Task UpdateSelectedDownload(DownloadStatus p_SelectedDownload);
 }

Then keep your original implementation returning Task

Example 2 - One-way method

 [ServiceContract(CallbackContract = typeof(IDownloadManagerServiceCalback))] 
 public interface IDownloadManagerServiceCalback
 {
     /// <summary>
     /// Returns changed downloading status to client.
     /// </summary>
     /// <returns>Downloading which has changed status</returns>
     [OperationContract(IsOneWay = true)]
     void UpdateSelectedDownload(DownloadStatus p_SelectedDownload);
 }

In your implementation remove any await; async; tasks.

General

Async WCF methods should return Task or Task < T > . The only time you have an async void is during an event handler which is not applicable here.

As a general rule with async methods - avoid async void like the plague because an exception thrown in a try catch inside such a method can not be caught by a regular try-catch. The only exception (no pun intended is during event handlers).

Async void methods have different error-handling semantics. When an exception is thrown out of an async Task or async Task method, that exception is captured and placed on the Task object. With async void methods, there is no Task object, so any exceptions thrown out of an async void method will be raised directly on the SynchronizationContext that was active when the async void method started. More...

Would you like to know more?

Best Practices in Asynchronous Programming