WCF Fault Exception not being propagated to client - wcf

Question

I have a WCF service that defines a FaultContract:
[OperationContract]
[FaultContract(typeof(InvalidOperationException))]
[FaultContract(typeof(NotSupportedException))]
[FaultContract(typeof(Exception))]
GetSysIdsResponse GetSysIds(string id);
The WCF service catches an exceptional case (null pointer exception) and throws my FaultException:
try
{
....
} }
catch (InvalidOperationException ex)
{
// The specified DirectoryEntry is not a container
throw new FaultException<InvalidOperationException>(ex);
}
catch (NotSupportedException ex)
{
// Search is not supported by the provider that is being used
throw new FaultException<NotSupportedException>(ex);
}
catch (Exception ex)
{
throw new FaultException<Exception>(ex);
}
It throws the last one. The thing is that it never gets to the client. First o9f all, "Fault contracts are published as part of the service metadata." I do not see it in the client metadata after I add the Service Reference.
Here is the client code. It never hits the catch block catch (FaultException e)
It just says the FaultException is uncaught by the user. It does catch the CommunicationException. I don't know what I am doing wrong?
try
{
response = client.GetSysIds("sgentil");
}
catch (FaultException<Exception> e)
{
Console.WriteLine("FaultException<Exception>: " + e.Detail);
client.Abort();
return;
}
catch (FaultException e)
{
Console.WriteLine("FaultException: " + e.Message);
client.Abort();
return;
}
catch (CommunicationException ex)
{
Console.WriteLine("CommunicationsException");
client.Abort();
return;
}
** I tried the approach of the first answer and defined two exceptions:
[DataContract]
public class SystemFault
{
[DataMember]
public string SystemOperation { get; set; }
[DataMember]
public string SystemReason { get; set; }
[DataMember]
public string SystemMessage { get; set; }
}
[DataContract]
public class DatabaseFault
{
[DataMember]
public string DbOperation { get; set; }
[DataMember]
public string DbReason { get; set; }
[DataMember]
public string DbMessage { get; set; }
}
I then applied it:
[FaultContract(typeof(SystemFault))]
GetSysIdsResponse GetSysIds(string id);
Then threw it:
catch (Exception ex)
{
SystemFault sf = new SystemFault
{
SystemOperation = "GetSystemIds",
SystemMessage = "Exception while obtaining AD user properties",
SystemReason = ex.Message
};
throw new FaultException<SystemFault>(sf);
}
The client DOES now see the SystemFault type and has that metadata:
catch(FaultException<SystemFault> sf)
{
Console.WriteLine("SystemFault {0}: {1}\n{2}",
sf.Detail.SystemOperation, sf.Detail.SystemMessage,
sf.Detail.SystemReason);
}
Yet still execution stops in the server at the line:
throw new FaultException<SystemFault>(sf);
It says:
FaultException'1 not handled by user code
Now what?

Answer 1

In my case, if the Interface was not marked with the following attributes the response was empty:
[System.ServiceModel.XmlSerializerFormatAttribute(SupportFaults = true)]
[System.ServiceModel.ServiceKnownTypeAttribute(typeof(Fault))]
You could mark your operation with those attributes in order to make the response display the fault details.

Answer 2

The problem is that you are specifying that your FaultContract is of type XXXException. This will not work I think, you must create a custom FaultContract of your own, for example:
[DataContract]
public class InitializationFault
{
public InitializationFault(Exception exc, string msg)
{
Exception = exc;
Message = msg;
}
[DataMember]
public Exception Exception { get; set; }
[DataMember]
public string Message { get; set; }
}
then your ServiceContract becomes:
[OperationContract]
[FaultContract(typeof(InitializationFault))]
//..more
GetSysIdsResponse GetSysIds(string id);
and your client side code becomes:
try
{
response = client.GetSysIds("sgentil");
}
catch (FaultException<InitializationFault> e)
{
Console.WriteLine("FaultException<InitializationFault>: " + e.Detail);
//more
}