I have no experience with WSCF.blue, so I tried to make a sample application to demonstrate a working scenario using a standard client and WCF server. Perhaps this will help you find the missing connections for your script to work.
I used BusinessRuleFaultExceptionType using the Code and Reason properties. BusinessRuleFaultExceptionType is a WCF failure contract.
I was a little lazy and implemented all the code in one console application. The Wcf client uses the same Datacontracts and ICalculator as Wcf. Sorry for the code. This will be a long post.
Datacontracts and Services Interface First
using System; using System.Runtime.Serialization; using System.ServiceModel; using System.ServiceModel.Channels; using System.ServiceModel.Description; using System.ServiceModel.Dispatcher; [ServiceContract(Namespace = "http://UE.ServiceModel.Samples")] public interface ICalculator { [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Add(double n1, double n2); [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Subtract(double n1, double n2); [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Multiply(double n1, double n2); [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Divide(double n1, double n2); }
Now the implementation of the service:
[ErrorBehavior(typeof(MyErrorHandler))] public class CalculatorService : ICalculator { public double Add(double n1, double n2) { double result = n1 + n2; Console.WriteLine("Received Add({0},{1})", n1, n2); Console.WriteLine("Return: {0}", result); throw new ArgumentException("My exception"); return result; } public double Subtract(double n1, double n2) { double result = n1 - n2; Console.WriteLine("Received Subtract({0},{1})", n1, n2); Console.WriteLine("Return: {0}", result); return result; } public double Multiply(double n1, double n2) { double result = n1 * n2; Console.WriteLine("Received Multiply({0},{1})", n1, n2); Console.WriteLine("Return: {0}", result); return result; } public double Divide(double n1, double n2) { double result = n1 / n2; Console.WriteLine("Received Divide({0},{1})", n1, n2); Console.WriteLine("Return: {0}", result); return result; } }
And client implementation:
public class Client : ClientBase<ICalculator>, ICalculator { public double Add(double n1, double n2) { try { return base.Channel.Add(n1, n2); } catch (FaultException<BusinessRuleFaultExceptionType> ex) { Console.WriteLine("This is my Code: {0}. This is the reason: {1}", ex.Detail.Code, ex.Detail.Reason); } catch (Exception ex) { throw; } return 0; } public double Subtract(double n1, double n2) { throw new NotImplementedException(); } public double Multiply(double n1, double n2) { throw new NotImplementedException(); } public double Divide(double n1, double n2) { throw new NotImplementedException(); } }
Main program to demonstrate this example
internal class Program { private static void Main(string[] args) { ServiceHost myServiceHost = new ServiceHost(typeof(CalculatorService));
Error handling execution:
/// <summary> /// Helper class for exception repackaging. /// </summary> internal class MyExceptionHandler { /// <summary> /// Handles thrown exception into internal exceptions that are being sent over to client. /// </summary> /// <param name="error">Exception thrown.</param> /// <returns>Repackaged exception.</returns> internal static Exception HandleError(Exception error) { // could do something here. return error; } } #region Behaviour /// <summary> /// Control the fault message returned to the caller and optionally perform custom error processing such as logging. /// </summary> public sealed class MyErrorHandler : IErrorHandler { /// <summary> /// Provide a fault. The Message fault parameter can be replaced, or set to null to suppress reporting a fault. /// </summary> /// <param name="error">The <see cref="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 <see cref="System.ServiceModel.Channels.Message"/> object that is returned to the client, or service, in the duplex case.</param> public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { //If it a FaultException already, then we have nothing to do if (error is FaultException) return; error = MyExceptionHandler.HandleError(error); var serviceDebug = OperationContext.Current.EndpointDispatcher.ChannelDispatcher.IncludeExceptionDetailInFaults; BusinessRuleFaultExceptionType f = new BusinessRuleFaultExceptionType { Code = -100, Reason = "xxx" }; FaultException<BusinessRuleFaultExceptionType> faultException = new FaultException<BusinessRuleFaultExceptionType>(f, error.Message); MessageFault faultMessage = faultException.CreateMessageFault(); fault = Message.CreateMessage(version, faultMessage, faultException.Action); } /// <summary> /// Enables error-related processing and returns a value that indicates whether the dispatcher aborts the session and the instance context in certain cases. /// </summary> /// <param name="error">The exception thrown during processing.</param> /// <returns>true if Windows Communication Foundation (WCF) should not abort the session (if there is one) and instance context if the instance context is not Single; otherwise, false. The default is false.</returns> public bool HandleError(Exception error) { // could use some logger like Nlog but as an example it will do. Console.WriteLine("Error occured. {0}", error); return true; } } /// <summary> /// This attribute is used to install a custom error handler for a service /// </summary> public sealed class ErrorBehaviorAttribute : Attribute, IServiceBehavior { /// <summary> /// Type of component to which this error handled should be bound /// </summary> private readonly Type errorHandlerType; /// <summary> /// Initializes a new instance of the ErrorBehaviorAttribute class. /// </summary> /// <param name="errorHandlerType">Type of component to which this error handled should be bound</param> public ErrorBehaviorAttribute(Type errorHandlerType) { this.errorHandlerType = errorHandlerType; } /// <summary> /// Type of component to which this error handled should be bound /// </summary> public Type ErrorHandlerType { get { return errorHandlerType; } } /// <summary> /// Provides the ability to inspect the service host and the service description to confirm that the service can run successfully. /// </summary> /// <param name="description"> /// <para>Type: <see cref="System.ServiceModel.Description.ServiceDescription"/></para> /// <para>The service description.</para> /// </param> /// <param name="serviceHostBase"> /// <para>Type: <see cref="System.ServiceModel.ServiceHostBase"/></para> /// <para>The service host that is currently being constructed.</para> /// </param> void IServiceBehavior.Validate(ServiceDescription description, ServiceHostBase serviceHostBase) { } /// <summary> /// Provides the ability to pass custom data to binding elements to support the contract implementation. /// </summary> /// <param name="description"> /// <para>Type: <see cref="System.ServiceModel.Description.ServiceDescription"/></para> /// <para>The service description.</para> /// </param> /// <param name="serviceHostBase"> /// <para>Type: <see cref="System.ServiceModel.ServiceHostBase"/></para> /// <para>The host of the service.</para> /// </param> /// <param name="endpoints"> /// <para>Type: <see cref="System.Collections.ObjectModel.Collection<ServiceEndpoint>"/></para> /// <para>The service endpoints.</para> /// </param> /// <param name="parameters"> /// <para>Type: <see cref="System.ServiceModel.Channels.BindingParameterCollection"/></para> /// <para>Custom objects to which binding elements have access.</para> /// </param> void IServiceBehavior.AddBindingParameters(ServiceDescription description, ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters) { } /// <summary> /// Provides the ability to change run-time property values or insert custom extension objects such as error handlers, message or parameter interceptors, security extensions, and other custom extension objects. /// </summary> /// <param name="description"> /// <para>Type: <see cref="System.ServiceModel.Description.ServiceDescription"/></para> /// <para>The service description.</para> /// </param> /// <param name="serviceHostBase"> /// <para>Type: <see cref="System.ServiceModel.ServiceHostBase"/></para> /// <para>The host that is currently being built.</para> /// </param> void IServiceBehavior.ApplyDispatchBehavior(ServiceDescription description, ServiceHostBase serviceHostBase) { IErrorHandler errorHandler; try { errorHandler = (IErrorHandler)Activator.CreateInstance(errorHandlerType); } catch (MissingMethodException e) { throw new ArgumentException("The errorHandlerType specified in the ErrorBehaviorAttribute constructor must have a public empty constructor.", e); } catch (InvalidCastException e) { throw new ArgumentException("The errorHandlerType specified in the ErrorBehaviorAttribute constructor must implement System.ServiceModel.Dispatcher.IErrorHandler.", e); } foreach (ChannelDispatcherBase channelDispatcherBase in serviceHostBase.ChannelDispatchers) { ChannelDispatcher channelDispatcher = channelDispatcherBase as ChannelDispatcher; channelDispatcher.ErrorHandlers.Add(errorHandler); } } } #endregion
And app.config of my console application:
<?xml version="1.0" encoding="utf-8" ?> <configuration> <startup> <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /> </startup> <system.serviceModel> <client> <endpoint address="http://localhost:12345/service/calc" binding="basicHttpBinding" contract="ConsoleApplication2.ICalculator" > </endpoint> </client> <services> <service name="ConsoleApplication2.CalculatorService" behaviorConfiguration="service"> <endpoint address="http://localhost:12345/service/calc" binding="basicHttpBinding" contract="ConsoleApplication2.ICalculator" > </endpoint> <host> <baseAddresses> <add baseAddress="http://localhost:12345/service/calc" /> </baseAddresses> </host> </service> </services> <behaviors> <serviceBehaviors> <behavior name="service"> <serviceMetadata httpGetEnabled="true" /> </behavior> </serviceBehaviors> </behaviors> </system.serviceModel> </configuration>
I used the WCF test client to send this request:
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"> <s:Header> <Action s:mustUnderstand="1" xmlns="http://schemas.microsoft.com/ws/2005/05/addressing/none">http://UE.ServiceModel.Samples/ICalculator/Add</Action> </s:Header> <s:Body> <Add xmlns="http://UE.ServiceModel.Samples"> <n1>0</n1> <n2>1</n2> </Add> </s:Body> </s:Envelope>
and got this answer:
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"> <s:Header /> <s:Body> <s:Fault> <faultcode>s:Client</faultcode> <faultstring xml:lang="sk-SK">My exception</faultstring> <detail> <BusinessRuleFaultExceptionType xmlns="http://someurl.temp" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"> <Code>-100</Code> <Reason>xxx</Reason> </BusinessRuleFaultExceptionType> </detail> </s:Fault> </s:Body> </s:Envelope>
When i called
Client c = new Client(); var res = c.Add(1, 2);
I caught the FaultException<BusinessRuleFaultExceptionType> ex which I ran in the console
Console.WriteLine("This is my Code: {0}. This is the reason: {1}", ex.Detail.Code, ex.Detail.Reason);
EDIT: I changed the namespaces in BusinessRuleFaultExceptionType and set the solution to use [XmlSerializerFormat(SupportFaults = true)] .
Changed interface, datacontracts and service implementation:
[ServiceContract(Namespace = "http://UE.ServiceModel.Samples")] [XmlSerializerFormat(SupportFaults = true)] public interface ICalculator { [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Add(double n1, double n2); [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Subtract(double n1, double n2); [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Multiply(double n1, double n2); [OperationContract(IsOneWay = false)] [FaultContract(typeof(BusinessRuleFaultExceptionType))] double Divide(double n1, double n2); }
I found an article about the reasons why there are problems using XmlSerializer in IErrorHandler. Therefore, I changed the service implementation to throw a FaultException in the method implementation and not rely on IErrorHandler.
I also found another (relatively old) article on how to use the XmlSerializer in IErroHandler , and after a while I made it possible to serialize even from IErrorHandler. I changed the exception to the trail back to ArgumentException. Here are the changes (I continued with the previous example, so maybe not all codes and attributes are required):
[DataContract(Name = "BusinessRuleFaultExceptionType", Namespace = "http://someurl.temp")] [XmlType("BusinessRuleFaultExceptionType", Namespace = "http://someurl.temp")] [XmlRoot("BusinessRuleFaultExceptionType", Namespace = "http://someurl.temp")] public sealed class BusinessRuleFaultExceptionType { //[DataMember] [XmlElement(IsNullable = false, Namespace = "http://namespaces2.url")] public int Code { get; set; } [XmlElement(IsNullable = false, Namespace = "http://namespaces2.url")] public string Reason { get; set; } } public class XmlSerializerMessageFault : MessageFault { FaultCode code; FaultReason reason; object details; public XmlSerializerMessageFault(FaultCode code, FaultReason reason, object details) { this.details = details; this.code = code; this.reason = reason; } public override FaultCode Code { get { return code; } } public override bool HasDetail { get { return (details != null); } } protected override void OnWriteDetailContents(System.Xml.XmlDictionaryWriter writer) { var ser = new XmlSerializer(details.GetType()); ser.Serialize(writer, details); writer.Flush(); } public override FaultReason Reason { get { return reason; } } } /// <summary> /// Control the fault message returned to the caller and optionally perform custom error processing such as logging. /// </summary> public sealed class MyErrorHandler : IErrorHandler { /// <summary> /// Provide a fault. The Message fault parameter can be replaced, or set to null to suppress reporting a fault. /// </summary> /// <param name="error">The <see cref="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 <see cref="System.ServiceModel.Channels.Message"/> object that is returned to the client, or service, in the duplex case.</param> public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { BusinessRuleFaultExceptionType f = new BusinessRuleFaultExceptionType { Code = -100, Reason = "xxx" }; // create a fault message containing our FaultContract object FaultException<BusinessRuleFaultExceptionType> faultException = new FaultException<BusinessRuleFaultExceptionType>(f, error.Message); MessageFault faultMessage = faultException.CreateMessageFault(); var msgFault = new XmlSerializerMessageFault(faultMessage.Code, faultMessage.Reason, f); fault = Message.CreateMessage(version, msgFault, faultException.Action); } /// <summary> /// Enables error-related processing and returns a value that indicates whether the dispatcher aborts the session and the instance context in certain cases. /// </summary> /// <param name="error">The exception thrown during processing.</param> /// <returns>true if Windows Communication Foundation (WCF) should not abort the session (if there is one) and instance context if the instance context is not Single; otherwise, false. The default is false.</returns> public bool HandleError(Exception error) { // could use some logger like Nlog but as an example it will do. Console.WriteLine("Error occured. {0}", error); return true; } }
In both cases, a serialized error:
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"> <s:Header /> <s:Body> <s:Fault> <faultcode>s:Client</faultcode> <faultstring xml:lang="sk-SK">My exception</faultstring> <detail> <BusinessRuleFaultExceptionType xmlns="http://someurl.temp" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Code xmlns="http://namespaces2.url">-100</Code> <Reason xmlns="http://namespaces2.url">xxx</Reason> </BusinessRuleFaultExceptionType> </detail> </s:Fault> </s:Body> </s:Envelope>