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=0; i<5; 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(1000 * (i + 1)); 
           }

           // 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(1000 * (i + 1)); 
           }

           // 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(1000 * (i + 1)); 
           }

           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