WCF客户端错误处理

Question

I'm consuming a clunky WCF server that occasionally throws various exceptions, and additionally returns some of its errors as string . I have no access to the server code at all.

I want to override the inner WCF-client request invocation method and handle all inner exceptions and hard-coded errors returned by the server and raise the Fault event if an error occurs, pseudo:

class MyClient : MyServiceSoapClient
{
    protected override OnInvoke()
    {
        object result;
        try
        {
            result = base.OnInvoke();
            if(result == "Error")
            {
                //raise fault event
            }
        catch
        {
            //raise fault event
        }
    }        
}

So that when I call myClient.GetHelloWorld() , it goes thru my overridden method.

How can this be achieved?
I know I don't have to use the generated client, but I don't want to re-implement all the contracts again, and I want to use the generated ClientBase subclass or at least its channel.
What I need is control over the inner request call method.

Update

I read this answer , and looks it's partially what I'm looking for, but I'm wondering if there is a way to attach an IErrorHandler to the consumer (client) code only, I want to add it to the ClientBase<TChannel> instance somehow.

Update

This article also looks very promising but it doesn't work. The applied attribute doesn't seem to take effect. I can't find a way to add IServiceBehavior to the client side.

Update

I tried attaching an IErrorHandler via IEndpointBehavior.ApplyClientBehavior calling:

public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
  clientRuntime.CallbackDispatchRuntime.ChannelDispatcher.ErrorHandlers
           .Add(new ErrorHandler());
}

( clientRuntime is a parameter), but exceptions are still thrown directly skipping MyErrorHandler .
ApplyDispatchBehavior isn't called at all.

Conclusion

I need to achieve two aspects:

1. Wrap all exceptions that might occur during the lifetime of a BaseClient<TChannel> and decide whether to handle them or throw them on. This should take care of all operation (the service I'm consuming exposes few dozens)
2. Parse all server-replies and throw exceptions for some of them, so they're forwarded as in statement 1.

Answer 1

You could use and modify the Exception Handling WCF Proxy Generator , more specifically, the base class that it uses. It's basic idea (check this description too) is to provide connection resilience by catching connection faults, and retrying the failed operation. As you can imagine, for this purpose it needs to be able to catch thrown exceptions, and also, it can inspect the result of calls.

The main functionality is given by the ExceptionHandlingProxyBase<T> base class, which you use instead of the ClientBase<T> . This base class has an Invoke method as follows, you'd need to modify that.

Simplified Invoke :

protected TResult Invoke<TResult>(string operationName, params object[] parameters)                              
{                                                        
  this.Open();                              
  MethodInfo methodInfo = GetMethod(operationName);                              
  TResult result = default(TResult);                              
  try                              
  {                              
    this.m_proxyRecreationLock.WaitOne(this.m_proxyRecreationLockWait); 
    result = (TResult)methodInfo.Invoke(m_channel, parameters);                              
  }                              
  catch (TargetInvocationException targetEx) // Invoke() always throws this type                              
  {                              
    CommunicationException commEx = targetEx.InnerException as CommunicationException;                              
    if (commEx == null)                              
    {                              
      throw targetEx.InnerException; // not a communication exception, throw it                              
    }                              
    FaultException faultEx = commEx as FaultException;                              
    if (faultEx != null)                              
    {                              
      throw targetEx.InnerException; // the service threw a fault, throw it                              
    }                              

    //... Retry logic

  }
  return result;
}  

You'll need to modify the throw targetEx.InnerException; part to handle the exceptions as you need, and obviously the resturn value shoudl also be inspected for your needs. Other then that you can leave the retry logic or throw it away if you don't expect connection problems. There is another variant of the Invoke for void return methods.

Oh, and by the way, it works with duplex channels as well, there is another base class for those.

If you don't want to use the generator (it might not even work in newer versions of VS), then you could just take the base class for example from here , and generate the actual implementation class with T4 from your service interface.

Answer 2

If the service isn't returning a true exception, but just a message, you probably want to add a ClientMessageInspector as a new client behavior. Please see: https://msdn.microsoft.com/en-us/library/ms733786.aspx

Answer 3

I've ended up using something based on the answers in this question.

It sticks to the generated client code, and allows invocation of the operations generically.

The code is incomplete, feel free to fork and edit it. Please notify me if you found any bugs or made any updates.

It's pretty bulky so I'll just share the usage code:

using (var proxy = new ClientProxy<MyServiceSoapClientChannel, MyServiceSoapChannel>())
{
  client.Exception += (sender, eventArgs) =>
  {
    //All the exceptions will get here, can be customized by overriding ClientProxy.
    Console.WriteLine($@"A '{eventArgs.Exception.GetType()}' occurred 
      during operation '{eventArgs.Operation.Method.Name}'.");
    eventArgs.Handled = true;
  };
  client.Invoke(client.Client.MyOperation, "arg1", "arg2");
}