Wcf – Catches communication exception instead of custom fault exception – WCF

exception handlingwcf

On Server I'm throwing the exception like this.

catch(SqlException exception)
{
  if (exception.Message.Contains("Custom error from stored proc"))
  {
    //Exception to be thrown when authentication fails.
    throw new FaultException<MyServiceFault>(new MyServiceFault { MessageText = exception.Message });
  }
}

And on client end I'm catching the exception

catch(FaultException<MyServiceFault> faultException)
{

}

Here is my MyServiceFault

[DataContract]
public class MyServiceFault  
{
  [DataMember]
  public string MessageText { get; set; }

  [DataMember]
  public Guid Id { get; set; }
}

The problem is that on client, it doesn't go to MyServiceFault catch block instead it goes to communication exception catch block and throws this error

System.ServiceModel.CommunicationException: The underlying connection was closed: The connection was closed unexpectedly. ---> System.Net.WebException

I've also decorated my service method [FaultContract(typeof(MyServiceFault))] in the interface which is implemented by my service.

In my web.config servicebehaviour tag consist
<serviceDebug includeExceptionDetailInFaults="true" />

Any idea where I'm going wrong.

This problem is occurring on windows 7. Can there be a reason related to it?

IMPORTANT UPDATE
According to answerers, any unhandled exception on the server can cause throwing of the Communication exception on the client side and it may not have anything to do with the custom fault exception you have thrown on the server. So the solution is log the errors on the server and find what error is causing this behavior. Here is a very useful open source logging functionality I found and implemented which can even be more useful after your project goes into production environment. Many thanks to the answerers.

A better way of logging exceptions in WCF

Best Answer

Add logging to your WCF calls by including this in your app.config.

<system.diagnostics>
  <trace autoflush="true" />
  <sources>
    <source name="System.ServiceModel" switchValue="Information, ActivityTracing">
      <listeners>
        <add name="sdt" type="System.Diagnostics.XmlWriterTraceListener" initializeData="c:\LogPath\LogFile.svclog" />
      </listeners>
    </source>
  </sources>
</system.diagnostics>

(You can do this for both server and client, obviously specifying different log files)

Once you've generated some logs, look through for exceptions or warnings. I often find this produces some very useful information that helps me solve WCF problems.

To read the log file, you'll need to use SvcTraceViewer.exe. Unfortunately the only way to get this is with the windows SDK which is a bit of a big download for one tiny little tool.

It's also worth bearing in mind that WCF can through the CommunctionException when it is being closed, and this is expected behaviour. You shouldn't just do using with client WCF comm channels. Instead, you should follow a pattern like this:

try{
    x.Close()
}
catch(Comms ex){
    x.Abort()
}

Related Solutions

WCF Web Service Custom Exception Error to Client

In WCF, you should not throw standard .NET exceptions - this is contrary to the potentially interoperable nature of WCF - after all, your client could be a Java or PHP client which has no concept of .NET exceptions.

Instead, you need to throw FaultExceptions (which is the standard behavior for WCF).

If you want to convey back more information about what went wrong, look at the generic FaultException<T> types:

SERVER:

public bool Read()
{
    if (IsUserValid() == false)
    {
        throw new FaultException<InvalidUserFault>("User invalid");
    }
}

Or alternatively (as suggested by @MortenNorgaard):

public bool Read()  
{ 
    if (!IsUserValid()) 
    { 
        InvalidUserFault fault = new InvalidUserFault(); 
        FaultReason faultReason = new FaultReason("Invalid user"); 

        throw new FaultException<InvalidUserFault>(fault, faultReason); 
    }   
}

CLIENT:

try
{
   _client.Read();
}
catch (FaultException<InvalidUserFault> e)
{
    MessageBox.Show(e.Message);
    return;
}

You should declare your InvalidUserFault as WCF data contracts and define what members might travel back with that type (i.e. error code, error message etc.).

 [DataContract]
 [Serializable()]
 public class BusinessFault
 {
   ... add your fault members here
 }

And you should then decorate your service methods with the possible faults it can throw:

[FaultContract(typeof(InvalidUserFault)]
[OperationContract]
public bool Read()
.....

Of course, the "quick'n'dirty" hack is to simply define that the server returns exception details in its FaultExceptions:

<serviceBehaviors>
   <behavior name="EmployeeManager_Behavior">
      <serviceDebug includeExceptionDetailInFaults="true"/>
   </behavior>
</serviceBehaviors>

and then you can inspect the FaultException's .Detail for the actual exception that happened on the server - but again: this is more of a development-time only hack rather than a real solution.

Marc

Wcf – Throwing FaultException using Custom Exception Handler EL WCF

I would consider using a custom WCF IErrorHandler implementation. It provides a place to centrally handle all unhandled exceptions that occur within your service methods.

In my opinion it ends up cleaner than using Ent Lib, is 1 less dependency, and you wont need that error mapping in your config, so less XML.

Example:

public class MyServiceErrorHandler : IErrorHandler
{
    /// <summary>
    /// Central error handling for WCF services.
    /// Whenever a service encounteres an unhandled exception, it will end up here.
    /// This method will log the error and continue with normal error processing.
    /// </summary>
    /// <param name="error">The unhandled exception thrown from a service method.</param>
    /// <returns>true if the exceptions has been handled, false if normal error processing should continue. This implementation will always return false.</returns>
    public virtual bool HandleError(Exception error)
    {
        return false; // returning false so that WCF will still process the exception as usual.
    }

    /// <summary>
    /// Create a custom Fault message to return to the client.
    /// </summary>
    /// <param name="error">The Exception object thrown in the course of the service operation.</param>
    /// <param name="version">The SOAP version of the message.</param>
    /// <param name="fault">The Message object that is returned to the client, or service, in the duplex case.</param>
    public virtual void ProvideFault(Exception error, MessageVersion version, ref Message fault)
    {
        //If it's a FaultException already, then we have nothing to do
        if (error is FaultException)
            return;

        // pack the exception info into the Fault Contract
        MyFaultContract details = new MyFaultContract();
        if (exception is NullReferenceException)
        {
            details.ErrorCode = MyFaultCode.NullReferenceException;
            details.OriginalMessage = error.Message;
            details.MyMessage = "Null Reference exception here!";
        }
        var faultException = new FaultException<MyFaultContract>(details);

        // turn the fault contract into the response WCF Message.
        var messageFault = faultException.CreateMessageFault();
        fault = Message.CreateMessage(version, messageFault, faultException.Action);
    }
}

Of course if you have other reasons to want to use Ent Lib, then go ahead. You can probably tie them both together somehow.

This link also has some good reading on error handling, including adding the custom IErrorHandler behavior: http://www.codeproject.com/KB/WCF/WCFErrorHandling.aspx

Best Answer

Related Solutions

WCF Web Service Custom Exception Error to Client

Wcf – Throwing FaultException using Custom Exception Handler EL WCF

Related Topic