|
1 |
originally posted 2012-8-24 |
WCF throws System.ServiceModel.FaultExceptions (FE) between the client and server. The FE is a System.Exception so the client does not need to explicitly catch FaultException, but the FE is missing something. It does not take an InnerException in its constructor, so the server-side chain of exceptions and stack trace data are not available to the client. The typical response to this is “That’s the way it’s supposed to work!”, but if you own/control the consumers of your web service and you want the exception chain and stack trace data, then you’ll want to use FaultException.
The first thing is to decorate your service operations with the FaultContract attribute:
|
1 2 3 4 5 6 7 8 |
//service interface public interface IService { [OperationContract(IsOneWay = false)] [FaultContract(typeof(ExceptionDetail))] Foo GetFoo(Guid id); } |
By default, the service implementation will throw all unhandled exceptions back to the client as a regular FaultException. To avoid this, catch exceptions and re-throw them as FaultException as such…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//service implementation public sealed partial class Service : IService { Foo IService.GetFoo(Guid id) { try { return FooLib.GetFoo(id); } catch (Exception ex) { throw new FaultException<ExceptionDetail>(new ExceptionDetail(ex), ex.Message); } } } |
Great! All that detail is on its way to your client.
FaultException and FaultException<>; are derived from System.Exception, so when you don’t care about the detail, just catch Exception. When you want the detail, catch FaultException and inspect …
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
try { ... ServiceReference.Foo foo = proxy.CreateFoo(fooId); } catch (FaultException<ExceptionDetail> fe) { string message = fe.Message; //the equivalent of Exception.Message ExceptionDetail detail = fe.Detail; //the latest exception data string trace = detail.StackTrace; //stack info ExceptionDetail nextError = detail.InnerException; //exception chain } catch (Exception ex) { ... } |
An instance of ExceptionDetail stores a copy of the underlying Exception data as well as the Exception’s InnerException data, which is also converted to a ExceptionDetail, thus preserving the data of the Exception chain. This means that custom exception types thrown by the server cannot specifically be caught by the client. It also means that the client does not need to reference these exception types. However, the client can determine the type of exception thrown by the server…
The client wishes to detect the ABC.EmptyGuidException thrown by a library called by the service implementation.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
//a library called by the service implementation public static class FooLib { public static GetFoo(Guid id) { if(Guid.Equals(Guid.Empty) throw new ABC.EmptyGuidException("No!") ... } } //the client try { ... ServiceReference.Foo foo = proxy.CreateFoo(fooId); } catch (FaultException<ExceptionDetail> fe) { ExceptionDetail detail = fe.Detail; switch(detail.Type) //this is the type's FullName! { case "ABC.EmptyGuidException": //do something here break; ... } } catch (Exception ex) { ... } |
Clunky, but attainable.