WCF全局异常处理

在用wcf做为单纯的服务端的时候，发生错误是常有的事情，特别是在调用其他系统提供的接口的时候，发生的一些错误总是让人摸不着头脑，严重影响了错误的定位。做.net web开发的时候，我们可以在Global里面直接捕获全局异常，那么wcf是否也可以定义全局异常处理？对于已有的系统，逐个方法添加异常处理是很不现实而且还会伴随很大的风险，那么我们肯定希望这种改动尽可能的小甚至不用改动。下面分享一下实现的方法：

利用Attribure和IServiceBehavior实现wcf全局异常处理

这种方式使用方便，基本不用改动原有的代码，效果如下：

 [WcfGlobalExceptionOpreationBehaviorAttribute(typeof(WcfGlobalErrorHandler))]

     public class DemoService : IDemoService

     {

     }

或者

 [WcfGlobalServiceInterceptor]

     public class DemoService : IDemoService

     {

     }

以上的两种方式在具体实现上稍有不同，具体实现方式如下：
在此之前先来看看IServiceBehavior接口提供的方法

 public interface IServiceBehavior

     {

         void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters);

         void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase);

         void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase);

     }

后面我们用到的是方法ApplyDispatchBehavior,这个方法会在服务Open的时候执行，我们可以在此注入我们自定义的异常处理程序，从而达到处理全局异常的目的（注：试验证明在服务Open之后再注入分发行为是无效的）。

形式一：IErrorHandler

可参考利用Attribute和IErrorHandler处理WCF全局异常

 private readonly Type _errorHandlerType;

         public WcfGlobalExceptionOpreationBehaviorAttribute(Type handlerType)

         {

             _errorHandlerType = handlerType;

         }

         /// <summary>

         /// 注入自定义异常处理程序

         /// </summary>

         /// <param name="serviceDescription"></param>

         /// <param name="serviceHostBase"></param>

         public void ApplyDispatchBehavior(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)

         {

             var handler = (IErrorHandler) Activator.CreateInstance(_errorHandlerType);

             foreach (ChannelDispatcher dis in serviceHostBase.ChannelDispatchers)

             {

                 dis.ErrorHandlers.Add(handler);

             }

         }

原理就是我们为信道分发器注入自定义的ErrorHandler

 /// <summary>

     /// WCF全局异常处理

     /// </summary>

     public class WcfGlobalErrorHandler:IErrorHandler

     {

         /// <summary>

         /// 启用错误相关处理并返回一个值

         /// </summary>

         /// <param name="ex"></param>

         /// <returns>是否终止会话和上下文</returns>

         public bool HandleError(System.Exception ex)

         {

             WcfGlobalEventHelper.FireException(new WcfGlobalException(ex.Message,ex.StackTrace,null,null));

             return true;

         }

         public void ProvideFault(System.Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault)

         {

         }

     }

形式二：IOperationBehavior

     public class WcfGlobalOperationInterceptorAttribute:Attribute,IOperationBehavior

     {

         private string operationMethod;

         public WcfGlobalOperationInterceptorAttribute(string methodName)

         {

             this.operationMethod = methodName;

         }

         public void AddBindingParameters(OperationDescription operationDescription, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)

         {

         }

         public void ApplyClientBehavior(OperationDescription operationDescription, System.ServiceModel.Dispatcher.ClientOperation clientOperation)

         {

         }

         public void ApplyDispatchBehavior(OperationDescription operationDescription, System.ServiceModel.Dispatcher.DispatchOperation dispatchOperation)

         {

             IOperationInvoker invoke = dispatchOperation.Invoker;

             dispatchOperation.Invoker = CreateInvoker(invoke);

         }

         public void Validate(OperationDescription operationDescription)

         {

         }

         protected OperationInvoker CreateInvoker(IOperationInvoker oldInvoker)

         {

             return new OperationInvoker(oldInvoker, this.operationMethod);

         }

     }

实际上就是在ApplyDispatchBehavior方法中分发操作的Invoker进行了封装

 /// <summary>

     /// 使用消息提取的对象以及参数数组，并利用对该对象调用方法，然后返回该方法的返回值和输出参数

     /// </summary>

     public class OperationInvoker:IOperationInvoker

     {

         private string operationMethod;//方法名称

         private IOperationInvoker invoker;//原invoker

         private Stopwatch sw;//用于计时

         public OperationInvoker(IOperationInvoker oldInvoker, string operationMethod)

         {

             this.invoker = oldInvoker;

             this.operationMethod = operationMethod;

             sw = new Stopwatch();

         }

         public object[] AllocateInputs()

         {

             return this.invoker.AllocateInputs();

         }

         /// <summary>

         /// 从一个实例和输入对象的集合返回一个对象和输出对象的集合

         /// </summary>

         /// <param name="instance"></param>

         /// <param name="inputs"></param>

         /// <param name="outputs"></param>

         /// <returns></returns>

         public object Invoke(object instance, object[] inputs, out object[] outputs)

         {

             this.PreInvoke(instance, inputs);

             object returnValue = null;

             object invokeValue;

             object[] objArray = new object[];

             System.Exception ex = null;

             try

             {

                 invokeValue = this.invoker.Invoke(instance, inputs, out objArray);

                 returnValue = invokeValue;

                 outputs = objArray;

             }

             catch (System.Exception e)

             {

                 ex = e;

                 returnValue = null;

                 outputs = null;

             }

             finally

             {

                 this.PostInvoke(instance,returnValue,objArray,ex);

             }

             return returnValue;

         }

         public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)

         {

             this.PreInvoke(instance,inputs);

             return this.invoker.InvokeBegin(instance, inputs, callback, state);

         }

         public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)

         {

             object returnValue = null;

             object invokeValue;

             object[] objArray = new object[];

             System.Exception ex = null;

             try

             {

                 invokeValue = this.invoker.InvokeEnd(instance,out outputs,result);

                 returnValue = invokeValue;

                 outputs = objArray;

             }

             catch (System.Exception e)

             {

                 ex = e;

                 returnValue = null;

                 outputs = null;

             }

             finally

             {

                 this.PostInvoke(instance, returnValue, objArray, ex);

             }

             return returnValue;

         }

         public bool IsSynchronous

         {

             get { return this.invoker.IsSynchronous; }

         }

         private void PreInvoke(object instance, object[] inputs)

         {

             sw.Start();

         }

         private void PostInvoke(object instane, object returnValue, object[] outputs, System.Exception ex)

         {

             this.sw.Stop();

             if (ex == null)//没有发生异常

             {

                 WcfGlobalInvocation invocation = new WcfGlobalInvocation(instane,this.operationMethod,this.sw.ElapsedMilliseconds);

                 WcfGlobalEventHelper.FireInvocation(invocation);

             }

             else //发生异常

             {

                 WcfGlobalException we = new WcfGlobalException(ex.Message, ex.StackTrace, instane, this.operationMethod);

                 WcfGlobalEventHelper.FireException(we);

                 throw ex;

             }

         }

     }

这种形式下我们就可以对原有的方法执行过程try.catch，捕获其中的异常。另外此种方式还有一个作用，就是可以监控wcf方法的执行时长，可用于发现服务的性能瓶颈。

其中这两种都用到一个类WcfGlobalEventHelper

 public delegate void WcfGlobalInvocationEventHandler(WcfGlobalInvocation invocation);

     public  class WcfGlobalEventHelper

     {

         //发生异常时

         private static EventHandlerList listExceptionHandler = new EventHandlerList();

         private static readonly object keyException = new object();

         //未发生异常时

         private static EventHandlerList listInvocationHandler = new EventHandlerList();

         private static readonly object keyInvocation = new object();

         /// <summary>

         /// wcf方法发生异常时触发该事件

         /// </summary>

         public static event WcfGlobalExceptionEventHandler OnGlobalExceptionExec

         {

             add { listExceptionHandler.AddHandler(keyException, value); }

             remove { listExceptionHandler.RemoveHandler(keyException, value); }

         }

         public static void FireException(WcfGlobalException ex)

         {

             var handler = (WcfGlobalExceptionEventHandler)listExceptionHandler[keyException];

             if(handler != null)

             {

                 handler(ex);

             }

         }

         /// <summary>

         /// wcf方法调用成功是触发该事件

         /// </summary>

         public static event WcfGlobalInvocationEventHandler onGlobalInvocationExec

         {

             add { listInvocationHandler.AddHandler(keyInvocation,value);}

             remove { listInvocationHandler.RemoveHandler(keyInvocation,value);}

         }

         public static void FireInvocation(WcfGlobalInvocation invocation)

         {

             var handler = (WcfGlobalInvocationEventHandler) listInvocationHandler[keyInvocation];

             if (handler != null)

             {

                 handler(invocation);

             }

         }

     }

通过这个类将异常以事件的形式抛出，在服务启动之前为其注册异常处理方法即可。我们一般是发生错误时发送邮件到开发者，这样开发者可以第一时间了解系统的异常，并能快速定位到发生异常的方法以及了解异常产生的大致原因。

下面是示例的完整代码，希望对有需要的朋友有用。这也是本人第一次写博客，有不当的地方还请各位海涵。

http://files.cnblogs.com/icewater506/WcfGlobalException.7z

巴特西

WCF全局异常处理

最新文章

热门文章