Wcf Client 异常和关闭的通用处理方法

在项目中采用wcf通讯，客户端很多地方调用服务，需要统一的处理超时和通讯异常以及关闭连接。

1.调用尝试和异常捕获

首先，项目中添加一个通用类ServiceDelegate.cs

 public delegate void UseServiceDelegate<T>(T proxy);

 public static class Service<T>
 {
     public static ChannelFactory<T> _channelFactory = new ChannelFactory<T>(""); 

     public static void Use(UseServiceDelegate<T> codeBlock)
     {
         T proxy = _channelFactory.CreateChannel();
         bool success = false;

        Exception mostRecentEx = null;
        for(int i=; i<; i++)  // Attempt a maximum of 5 times
        {
            try
            {
                codeBlock(proxy);
                proxy.Close();
                success = true;
                break;
            }

            // The following is typically thrown on the client when a channel is terminated due to the server closing the connection.
            catch (ChannelTerminatedException cte)
            {
               mostRecentEx = cte;
                proxy.Abort();
                //  delay (backoff) and retry
                Thread.Sleep( * (i + ));
            }

            // The following is thrown when a remote endpoint could not be found or reached.  The endpoint may not be found or
            // reachable because the remote endpoint is down, the remote endpoint is unreachable, or because the remote network is unreachable.
            catch (EndpointNotFoundException enfe)
            {
               mostRecentEx = enfe;
                proxy.Abort();
                //  delay (backoff) and retry
                Thread.Sleep( * (i + ));
            }

            // The following exception that is thrown when a server is too busy to accept a message.
            catch (ServerTooBusyException stbe)
            {
               mostRecentEx = stbe;
                proxy.Abort();

                //  delay (backoff) and retry
                Thread.Sleep( * (i + ));
            }

            catch(Exception  )
            {
                 // rethrow any other exception not defined here
                 // You may want to define a custom Exception class to pass information such as failure count, and failure type
                 proxy.Abort();
                 throw ;
            }
        }
        if (mostRecentEx != null)
        {
            proxy.Abort();
            throw new Exception("WCF call failed after 5 retries.", mostRecentEx );
        }

     }
 }

然后，这样调用：

无返回值：

Service<IOrderService>.Use(orderService=>
{
  orderService.PlaceOrder(request);
}

有返回值：

int newOrderId = 0; // need a value for definite assignment
Service<IOrderService>.Use(orderService=>
  {
    newOrderId = orderService.PlaceOrder(request);
  });
Console.WriteLine(newOrderId); // should be updated

2.使用Using方式确保关闭

在客户端扩展一个wcf client的部分类，重写Dispose方法，代码如下：

 namespace 命名空间要和生成的代码里一致
 {
     /// <summary>
     ///     ExtDataClient
     /// </summary>
     public partial class *****Client : IDisposable
     {
         #region IDisposable implementation

         /// <summary>
         ///     IDisposable.Dispose implementation, calls Dispose(true).
         /// </summary>
         void IDisposable.Dispose()
         {
             Dispose(true);
         }

         /// <summary>
         ///     Dispose worker method. Handles graceful shutdown of the
         ///     client even if it is an faulted state.
         /// </summary>
         /// <param name="disposing">
         ///     Are we disposing (alternative
         ///     is to be finalizing)
         /// </param>
         protected virtual void Dispose(bool disposing)
         {
             if (disposing)
             {
                 try
                 {
                     if (State != CommunicationState.Faulted)
                     {
                         Close();
                     }
                 }
                 finally
                 {
                     if (State != CommunicationState.Closed)
                     {
                         Abort();
                     }
                 }
             }
         }

         /// <summary>
         ///     Finalizer.
         /// </summary>
         ~*****Client()
         {
             Dispose(false);
         }

         #endregion
     }
 }

调用的地方可以直接使用using包起来了
using（****Client client=new ****Client()){//处理逻辑，可以使用try包起来}

3.我自己用到的处理方式，实现一个服务调用单例类，每个服务实现一个调用方法

    /// <summary>
         /// 调用SysSvc服务,统一处理TimeoutException和CommunicationException异常
         /// 用法：
         ///  List<ModuleEO/> list = SvcClient.Instance.SysClientCall(q => q.GetAllModules());
         /// </summary>
         /// <typeparam name="TResult">返回值</typeparam>
         /// <param name="func">调用的方法</param>
         /// <returns>泛型返回值</returns>
         public TResult SysClientCall<TResult>(Func<SysClient, TResult> func)
         {
             var client = this.GetSysClient();
             try
             {
                 TResult rec = func.Invoke(client);
                 client.Close();
                 return rec;
             }
             catch (TimeoutException ex)
             {
                 //服务器超时错误，提示用户即可。
                 client.Abort();
                 MessageBox.Show("服务器通讯超时，请重新尝试。");
             }
             catch (CommunicationException ex)
             {
                 //服务器连接通讯异常，提示用户即可。
                 client.Abort();
                 MessageBox.Show("服务器通讯错误，请重新尝试。");
             }
             catch (Exception ex)
             {
                 //未处理异常，重新抛出
                 client.Abort();
                 throw;
             }
             return default(TResult);
         }

参考链接：

http://stackoverflow.com/questions/573872/what-is-the-best-workaround-for-the-wcf-client-using-block-issue

http://stackoverflow.com/questions/6130331/how-to-handle-wcf-exceptions-consolidated-list-with-code