From f3f7f4e649cbb31e5f51d7a1f104cd20a85f17fd Mon Sep 17 00:00:00 2001
From: Val Melamed <valo@vtmelamed.com>
Date: Fri, 5 Feb 2016 17:26:45 -0500
Subject: [PATCH] sync

---
 Aspects/Facilities/ExceptionPolicyProvider.cs |  18 +++
 Aspects/Policies/CallTraceCallHandler.cs      |  44 +++---
 .../Ciphers/EncryptedKey/EncryptedKey.csproj  |   3 +
 Aspects/SemanticVersion.Metadata.cs           |  22 +++
 Aspects/SemanticVersion.cs                    |   4 +-
 .../ExceptionShieldingErrorHandler.cs         |   2 +-
 .../Behaviors/ValidatingParameterInspector.cs |  39 ++---
 Aspects/Wcf/Behaviors/WcfContextUtilities.cs  |   2 +-
 .../WebContentTypeMapperDefaultJson.cs        |   2 +-
 Aspects/Wcf/Clients/InterceptorLightClient.cs |  55 +++++--
 Aspects/Wcf/Clients/LightClient.cs            |  51 +++++--
 Aspects/Wcf/Clients/LightClientBase.cs        |  79 +++++++---
 Aspects/Wcf/CustomDataContext.cs              | 137 ++++++++++++++----
 .../Wcf/DataContracts/DataTransferObject.cs   |   2 +-
 Aspects/Wcf/FaultContracts/BusinessFault.cs   |   2 +-
 Aspects/Wcf/FaultContracts/Fault.cs           |  45 +++---
 Aspects/Wcf/FaultContracts/IOFault.cs         |   2 +-
 .../FaultContracts/InvalidOperationFault.cs   |   2 +-
 .../FaultContracts/Metadata/FaultMetadata.cs  |   9 +-
 .../ProtocolExceptionToWebFaultResolver.cs    |  80 ++++++++++
 .../ServiceCallTraceCallHandler.cs            |   6 +-
 Aspects/Wcf/vm.Aspects.Wcf.csproj             |   1 +
 Aspects/vm.Aspects.csproj                     |   4 +
 23 files changed, 478 insertions(+), 133 deletions(-)
 create mode 100644 Aspects/SemanticVersion.Metadata.cs
 create mode 100644 Aspects/Wcf/FaultContracts/ProtocolExceptionToWebFaultResolver.cs

diff --git a/Aspects/Facilities/ExceptionPolicyProvider.cs b/Aspects/Facilities/ExceptionPolicyProvider.cs
index 685a2aa..363aec9 100644
--- a/Aspects/Facilities/ExceptionPolicyProvider.cs
+++ b/Aspects/Facilities/ExceptionPolicyProvider.cs
@@ -2,7 +2,9 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
+using System.Globalization;
 using System.Linq;
+using System.Text;
 using Microsoft.Practices.EnterpriseLibrary.ExceptionHandling;
 using Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging;
 using Microsoft.Practices.ServiceLocation;
@@ -154,8 +156,24 @@ public static ExceptionManager CreateExceptionManager()
                         // add a new policy
                         policyEntries[d.Key] = d.Value.ToList();
                     else
+                    {
+                        var duplicates = list.Intersect(d.Value).ToList();
+
+                        if (duplicates.Any())
+                        {
+                            var message = new StringBuilder(
+                                                string.Format(
+                                                    CultureInfo.InvariantCulture,
+                                                    "One of the exception policy providers brings duplicate exception entries to policy {0}:\n{1}",
+                                                    d.Key,
+                                                    string.Join("\n  ", duplicates.Select(x => x.ExceptionType.FullName))));
+
+                            throw new InvalidOperationException(message.ToString());
+                        }
+
                         // add the entries to the existing policy
                         list.AddRange(d.Value);
+                    }
 
             // create the exception manager
             var exceptionManager = new ExceptionManager(
diff --git a/Aspects/Policies/CallTraceCallHandler.cs b/Aspects/Policies/CallTraceCallHandler.cs
index d78a0d0..1d6019a 100644
--- a/Aspects/Policies/CallTraceCallHandler.cs
+++ b/Aspects/Policies/CallTraceCallHandler.cs
@@ -189,6 +189,16 @@ public IMethodReturn Invoke(
         #endregion
 
         #region Overridables
+
+        /// <summary>
+        /// Creates the call data.
+        /// </summary>
+        /// <returns>CallData.</returns>
+        protected virtual CallData CreateCallData()
+        {
+            return new CallData();
+        }
+
         /// <summary>
         /// Creates and fills a new call data object with additional audit data about the call.
         /// </summary>
@@ -200,7 +210,7 @@ protected virtual CallData GetCallData(
             Contract.Requires<ArgumentNullException>(input != null, nameof(input));
             Contract.Ensures(Contract.Result<CallData>() != null);
 
-            var callData = new CallData();
+            var callData = CreateCallData();
 
             if (IncludeCallStack)
                 callData.CallStack = Environment.StackTrace;
@@ -545,7 +555,7 @@ protected void DumpParameters(
 
             writer.Write("(");
             writer.Indent(2);
-            for (var i=0; i<input.Inputs.Count; i++)
+            for (var i = 0; i<input.Inputs.Count; i++)
             {
                 // dump the parameter
                 DumpParameter(writer, input.Inputs.GetParameterInfo(i), input.Inputs[i]);
@@ -577,7 +587,7 @@ protected void DumpParametersAfterCall(
             writer.Indent(2);
 
             // dump the parameters
-            for (var i=0; i<input.Inputs.Count; i++)
+            for (var i = 0; i<input.Inputs.Count; i++)
             {
                 var pi = input.Inputs.GetParameterInfo(i);
 
@@ -701,20 +711,20 @@ protected void DumpResult(
             }
             else
                 if (IncludeReturnValue && methodReturn.ReturnValue!=null)
-                {
-                    var methodInfo = input.MethodBase as MethodInfo;
-
-                    if (methodInfo == null || methodInfo.ReturnType == typeof(void))
-                        return;
-
-                    writer.Write("RETURN VALUE: ");
-                    methodReturn.ReturnValue.DumpText(
-                        writer,
-                        2,
-                        null,
-                        methodInfo.ReturnTypeCustomAttributes
-                                  .GetCustomAttribute<DumpAttribute>());
-                }
+            {
+                var methodInfo = input.MethodBase as MethodInfo;
+
+                if (methodInfo == null || methodInfo.ReturnType == typeof(void))
+                    return;
+
+                writer.Write("RETURN VALUE: ");
+                methodReturn.ReturnValue.DumpText(
+                    writer,
+                    2,
+                    null,
+                    methodInfo.ReturnTypeCustomAttributes
+                              .GetCustomAttribute<DumpAttribute>());
+            }
         }
     }
 }
diff --git a/Aspects/Security/Cryptography/Ciphers/EncryptedKey/EncryptedKey.csproj b/Aspects/Security/Cryptography/Ciphers/EncryptedKey/EncryptedKey.csproj
index 76b1288..b161dde 100644
--- a/Aspects/Security/Cryptography/Ciphers/EncryptedKey/EncryptedKey.csproj
+++ b/Aspects/Security/Cryptography/Ciphers/EncryptedKey/EncryptedKey.csproj
@@ -256,6 +256,9 @@
       <Name>vm.Aspects.Security.Cryptography.Ciphers</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <WCFMetadata Include="Service References\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Aspects/SemanticVersion.Metadata.cs b/Aspects/SemanticVersion.Metadata.cs
new file mode 100644
index 0000000..9583740
--- /dev/null
+++ b/Aspects/SemanticVersion.Metadata.cs
@@ -0,0 +1,22 @@
+using vm.Aspects.Diagnostics;
+
+namespace vm.Aspects
+{
+    abstract class SemanticVersionMetadata
+    {
+        [Dump(0)]
+        public object Major { get; set; }
+
+        [Dump(1)]
+        public object Minor { get; set; }
+
+        [Dump(2)]
+        public object Patch { get; set; }
+
+        [Dump(3)]
+        public object Prerelease { get; set; }
+
+        [Dump(4)]
+        public object Build { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Aspects/SemanticVersion.cs b/Aspects/SemanticVersion.cs
index 46aeeef..6746915 100644
--- a/Aspects/SemanticVersion.cs
+++ b/Aspects/SemanticVersion.cs
@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel.DataAnnotations;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Globalization;
@@ -9,7 +10,8 @@ namespace vm.Aspects
     /// <summary>
     /// Class SemanticVersion as defined at http://semver.org/.
     /// </summary>
-    public sealed class SemanticVersion : IEquatable<SemanticVersion>, IComparable<SemanticVersion>
+    [MetadataType(typeof(SemanticVersionMetadata))]
+    public sealed partial class SemanticVersion : IEquatable<SemanticVersion>, IComparable<SemanticVersion>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="SemanticVersion"/> class.
diff --git a/Aspects/Wcf/Behaviors/ExceptionShieldingErrorHandler.cs b/Aspects/Wcf/Behaviors/ExceptionShieldingErrorHandler.cs
index 029c8dd..e3e27ad 100644
--- a/Aspects/Wcf/Behaviors/ExceptionShieldingErrorHandler.cs
+++ b/Aspects/Wcf/Behaviors/ExceptionShieldingErrorHandler.cs
@@ -206,7 +206,7 @@ void HandleFaultWrapper(
 
                     // we need to build a JSON or XML message out of the wrapped fault and put it in the web response:
                     BuildHttpResponseMessage(
-                        faultContractWrapper.FaultContract,
+                        faultDetails,
                         action,
                         faultDetails?.HttpStatusCode ?? HttpStatusCode.InternalServerError,
                         ref fault);
diff --git a/Aspects/Wcf/Behaviors/ValidatingParameterInspector.cs b/Aspects/Wcf/Behaviors/ValidatingParameterInspector.cs
index 8ced922..f7a5f32 100644
--- a/Aspects/Wcf/Behaviors/ValidatingParameterInspector.cs
+++ b/Aspects/Wcf/Behaviors/ValidatingParameterInspector.cs
@@ -1,15 +1,14 @@
 using System;
-using System.Linq;
 using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Linq;
 using System.Reflection;
 using System.ServiceModel;
 using System.ServiceModel.Description;
 using System.ServiceModel.Dispatcher;
-using vm.Aspects.Exceptions;
+using System.ServiceModel.Web;
 using Microsoft.Practices.EnterpriseLibrary.Validation;
-using Microsoft.Practices.EnterpriseLibrary.Validation.PolicyInjection;
 using Microsoft.Practices.EnterpriseLibrary.Validation.Validators;
-using System.Diagnostics.Contracts;
 using vm.Aspects.Facilities;
 using vm.Aspects.Wcf.FaultContracts;
 
@@ -38,11 +37,11 @@ public class ValidatingParameterInspector : IParameterInspector
         /// <param name="ruleset">The ruleset.</param>
         /// <exception cref="System.ArgumentNullException">operation</exception>
         public ValidatingParameterInspector(
-            OperationDescription operation, 
+            OperationDescription operation,
             string ruleset)
         {
             Contract.Requires<ArgumentNullException>(operation != null, nameof(operation));
-            
+
             var methodInfo = operation.SyncMethod ?? operation.BeginMethod ?? operation.TaskMethod;
 
             if (methodInfo == null)
@@ -72,13 +71,13 @@ public ValidatingParameterInspector(
         /// <param name="ruleset">The ruleset.</param>
         /// <returns>Validator.</returns>
         static Validator CreateInputParameterValidator(
-            ParameterInfo param, 
+            ParameterInfo param,
             string ruleset)
         {
             Contract.Requires<ArgumentNullException>(param != null, nameof(param));
 
             return new AndCompositeValidator(
-                            ParameterValidatorFactory.CreateValidator(param), 
+                            ParameterValidatorFactory.CreateValidator(param),
                             Facility.ValidatorFactory.CreateValidator(param.ParameterType, ruleset));
         }
 
@@ -94,24 +93,30 @@ static Validator CreateInputParameterValidator(
         /// <exception cref="FaultException{ValidationFault}"></exception>
         /// <exception cref="ValidationFault"></exception>
         public object BeforeCall(
-            string operationName, 
+            string operationName,
             object[] inputs)
         {
             Contract.Ensures(Contract.Result<object>() == null);
 
             if (inputs == null)
                 throw new ArgumentNullException("inputs");
-            
+
             var results = new ValidationResults();
 
-            for (var i=0; i<InputValidators.Count(); i++)
+            for (var i = 0; i<InputValidators.Count(); i++)
                 InputValidators[i].DoValidate(inputs[i], inputs[i], InputValidatorParameterNames[i], results);
 
             if (results.IsValid)
                 return null;
 
-            throw new FaultException<ValidationFault>(
-                        AddFaultDetails(new ValidationFault(), results));
+            var validationFault = new ValidationFault();
+
+            if (WebOperationContext.Current != null)
+                throw new WebFaultException<ValidationFault>(
+                            AddFaultDetails(validationFault, results), validationFault.HttpStatusCode);
+            else
+                throw new FaultException<ValidationFault>(
+                                AddFaultDetails(validationFault, results));
         }
 
         /// <summary>
@@ -122,9 +127,9 @@ public object BeforeCall(
         /// <param name="returnValue">The return value of the operation.</param>
         /// <param name="correlationState">Any correlation state returned from the <see cref="M:System.ServiceModel.Dispatcher.IParameterInspector.BeforeCall(System.String,System.Object[])" /> method, or null.</param>
         public void AfterCall(
-            string operationName, 
-            object[] outputs, 
-            object returnValue, 
+            string operationName,
+            object[] outputs,
+            object returnValue,
             object correlationState)
         {
             // We don't need to do anything after the call
@@ -137,7 +142,7 @@ public void AfterCall(
         /// <param name="results">The results.</param>
         /// <returns>ValidationFault.</returns>
         static ValidationFault AddFaultDetails(
-            ValidationFault fault, 
+            ValidationFault fault,
             ValidationResults results)
         {
             Contract.Requires<ArgumentNullException>(results != null, nameof(results));
diff --git a/Aspects/Wcf/Behaviors/WcfContextUtilities.cs b/Aspects/Wcf/Behaviors/WcfContextUtilities.cs
index a6810ef..c0e7b41 100644
--- a/Aspects/Wcf/Behaviors/WcfContextUtilities.cs
+++ b/Aspects/Wcf/Behaviors/WcfContextUtilities.cs
@@ -116,7 +116,7 @@ public string GetFaultedAction(
                         .EndpointDispatcher
                         .DispatchRuntime
                         .Operations
-                        .FirstOrDefault(o => o.Name.Equals(operationAction, StringComparison.OrdinalIgnoreCase))
+                        .FirstOrDefault(o => operationAction.Equals(o.Name, StringComparison.OrdinalIgnoreCase))
                         ?.FaultContractInfos
                         ?.FirstOrDefault(f => f.Detail == faultContractType)
                         ?.Action
diff --git a/Aspects/Wcf/Bindings/WebContentTypeMapperDefaultJson.cs b/Aspects/Wcf/Bindings/WebContentTypeMapperDefaultJson.cs
index f00df57..d178935 100644
--- a/Aspects/Wcf/Bindings/WebContentTypeMapperDefaultJson.cs
+++ b/Aspects/Wcf/Bindings/WebContentTypeMapperDefaultJson.cs
@@ -33,7 +33,7 @@ public override WebContentFormat GetMessageFormatForContentType(
                     return WebContentFormat.Xml;
                 }
 
-            return WebContentFormat.Default;
+            return WebContentFormat.Json;
         }
     }
 }
diff --git a/Aspects/Wcf/Clients/InterceptorLightClient.cs b/Aspects/Wcf/Clients/InterceptorLightClient.cs
index a3e8654..1fe1daa 100644
--- a/Aspects/Wcf/Clients/InterceptorLightClient.cs
+++ b/Aspects/Wcf/Clients/InterceptorLightClient.cs
@@ -4,11 +4,12 @@
 using System.Security.Cryptography.X509Certificates;
 using System.ServiceModel;
 using System.ServiceModel.Channels;
+using vm.Aspects.Wcf.Bindings;
 
 namespace vm.Aspects.Wcf.Clients
 {
     /// <summary>
-    /// A lightweight WCF service client class based on <see cref="T:ChannelFactory{T}"/>, includes interceptor behavior.
+    /// A lightweight WCF service client class based on <see cref="ChannelFactory{T}"/>, includes interceptor behavior.
     /// </summary>
     /// <typeparam name="TContract">The service interface.</typeparam>
     public abstract class InterceptorLightClient<TContract> : LightClientBase<TContract>, ICallIntercept where TContract : class
@@ -38,7 +39,7 @@ public virtual void PostInvoke(ref Message reply)
 
         #region Constructors
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:InterceptorLightClient{T}"/> class
+        /// Initializes a new instance of the <see cref="InterceptorLightClient{T}"/> class
         /// from an endpoint configuration section given by the <paramref name="endpointConfigurationName"/> and a remote address.
         /// If <paramref name="endpointConfigurationName"/> is <see langword="null" />, empty or consist of whitespace characters
         /// the constructor will try to resolve the binding from the schema in the given remote address from the <see cref="DIContainer"/>.
@@ -48,11 +49,17 @@ public virtual void PostInvoke(ref Message reply)
         /// The remote address. If the remote address is <see langword="null" /> or empty
         /// the constructor will try to use the address in the endpoint configuration.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected InterceptorLightClient(
             string endpointConfigurationName,
-            string remoteAddress)
-            : base(endpointConfigurationName, remoteAddress)
+            string remoteAddress,
+            string messagingPattern = null)
+            : base(endpointConfigurationName, remoteAddress, messagingPattern)
         {
             Contract.Requires<ArgumentException>(
                 !string.IsNullOrWhiteSpace(endpointConfigurationName) &&
@@ -75,12 +82,18 @@ protected InterceptorLightClient(
         /// If the identity type is <see cref="ServiceIdentity.Upn" /> - use the UPN of the service identity; if <see cref="ServiceIdentity.Spn" /> - use the SPN and if
         /// <see cref="ServiceIdentity.Rsa" /> - use the RSA key.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected InterceptorLightClient(
             string remoteAddress,
             ServiceIdentity identityType,
-            string identity)
-            : base(remoteAddress, identityType, identity)
+            string identity,
+            string messagingPattern = null)
+            : base(remoteAddress, identityType, identity, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
             Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(remoteAddress), "The argument \"remoteAddress\" cannot be null, empty or consist of whitespace characters only.");
@@ -104,12 +117,18 @@ protected InterceptorLightClient(
         /// Type of the identity: can be <see cref="ServiceIdentity.Certificate" /> or <see cref="ServiceIdentity.Rsa" />.
         /// </param>
         /// <param name="certificate">The identifying certificate.</param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected InterceptorLightClient(
             string remoteAddress,
             ServiceIdentity identityType,
-            X509Certificate2 certificate)
-            : base(remoteAddress, identityType, certificate)
+            X509Certificate2 certificate,
+            string messagingPattern = null)
+            : base(remoteAddress, identityType, certificate, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
             Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(remoteAddress), "The argument \"remoteAddress\" cannot be null, empty or consist of whitespace characters only.");
@@ -137,13 +156,19 @@ protected InterceptorLightClient(
         /// If the identity type is <see cref="ServiceIdentity.Upn" /> - use the UPN of the service identity; if <see cref="ServiceIdentity.Spn" /> - use the SPN and if
         /// <see cref="ServiceIdentity.Rsa" /> - use the RSA key.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected InterceptorLightClient(
             Binding binding,
             string remoteAddress,
             ServiceIdentity identityType,
-            string identity)
-            : base(binding, remoteAddress, identityType, identity)
+            string identity,
+            string messagingPattern = null)
+            : base(binding, remoteAddress, identityType, identity, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(binding != null, nameof(binding));
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
@@ -169,13 +194,19 @@ protected InterceptorLightClient(
         /// Type of the identity: can be <see cref="ServiceIdentity.Certificate" /> or <see cref="ServiceIdentity.Rsa" />.
         /// </param>
         /// <param name="certificate">The identifying certificate.</param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected InterceptorLightClient(
             Binding binding,
             string remoteAddress,
             ServiceIdentity identityType,
-            X509Certificate2 certificate)
-            : base(binding, remoteAddress, identityType, certificate)
+            X509Certificate2 certificate,
+            string messagingPattern = null)
+            : base(binding, remoteAddress, identityType, certificate, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(binding != null, nameof(binding));
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
diff --git a/Aspects/Wcf/Clients/LightClient.cs b/Aspects/Wcf/Clients/LightClient.cs
index c5c237a..5874fe3 100644
--- a/Aspects/Wcf/Clients/LightClient.cs
+++ b/Aspects/Wcf/Clients/LightClient.cs
@@ -4,6 +4,7 @@
 using System.Security.Cryptography.X509Certificates;
 using System.ServiceModel;
 using System.ServiceModel.Channels;
+using vm.Aspects.Wcf.Bindings;
 
 namespace vm.Aspects.Wcf.Clients
 {
@@ -26,11 +27,17 @@ public class LightClient<TContract> : LightClientBase<TContract> where TContract
         /// <param name="endpointConfigurationName">Name of the endpoint configuration.</param>
         /// <param name="remoteAddress">The remote address. If the remote address is <see langword="null" /> or empty
         /// the constructor will try to use the address in the endpoint configuration.</param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         public LightClient(
             string endpointConfigurationName,
-            string remoteAddress)
-            : base(endpointConfigurationName, remoteAddress)
+            string remoteAddress,
+            string messagingPattern = null)
+            : base(endpointConfigurationName, remoteAddress, messagingPattern)
         {
             Contract.Requires<ArgumentException>(
                 !string.IsNullOrWhiteSpace(endpointConfigurationName) ||
@@ -52,12 +59,18 @@ public LightClient(
         /// If the identity type is <see cref="ServiceIdentity.Upn" /> - use the UPN of the service identity; if <see cref="ServiceIdentity.Spn" /> - use the SPN and if
         /// <see cref="ServiceIdentity.Rsa" /> - use the RSA key.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         public LightClient(
             string remoteAddress,
             ServiceIdentity identityType,
-            string identity)
-            : base(remoteAddress, identityType, identity)
+            string identity,
+            string messagingPattern = null)
+            : base(remoteAddress, identityType, identity, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
             Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(remoteAddress), "The argument \"remoteAddress\" cannot be null, empty or consist of whitespace characters only.");
@@ -80,12 +93,18 @@ public LightClient(
         /// Type of the identity: can be <see cref="ServiceIdentity.Certificate" /> or <see cref="ServiceIdentity.Rsa" />.
         /// </param>
         /// <param name="certificate">The identifying certificate.</param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         public LightClient(
             string remoteAddress,
             ServiceIdentity identityType,
-            X509Certificate2 certificate)
-            : base(remoteAddress, identityType, certificate)
+            X509Certificate2 certificate,
+            string messagingPattern = null)
+            : base(remoteAddress, identityType, certificate, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
             Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(remoteAddress), "The argument \"remoteAddress\" cannot be null, empty or consist of whitespace characters only.");
@@ -112,13 +131,19 @@ public LightClient(
         /// If the identity type is <see cref="ServiceIdentity.Upn" /> - use the UPN of the service identity; if <see cref="ServiceIdentity.Spn" /> - use the SPN and if
         /// <see cref="ServiceIdentity.Rsa" /> - use the RSA key.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         public LightClient(
             Binding binding,
             string remoteAddress,
             ServiceIdentity identityType,
-            string identity)
-            : base(binding, remoteAddress, identityType, identity)
+            string identity,
+            string messagingPattern = null)
+            : base(binding, remoteAddress, identityType, identity, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(binding != null, nameof(binding));
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
@@ -143,13 +168,19 @@ public LightClient(
         /// Type of the identity: can be <see cref="ServiceIdentity.Certificate" /> or <see cref="ServiceIdentity.Rsa" />.
         /// </param>
         /// <param name="certificate">The identifying certificate.</param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         public LightClient(
             Binding binding,
             string remoteAddress,
             ServiceIdentity identityType,
-            X509Certificate2 certificate)
-            : base(binding, remoteAddress, identityType, certificate)
+            X509Certificate2 certificate,
+            string messagingPattern = null)
+            : base(binding, remoteAddress, identityType, certificate, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(binding != null, nameof(binding));
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
diff --git a/Aspects/Wcf/Clients/LightClientBase.cs b/Aspects/Wcf/Clients/LightClientBase.cs
index 9ed9cbc..4d996e2 100644
--- a/Aspects/Wcf/Clients/LightClientBase.cs
+++ b/Aspects/Wcf/Clients/LightClientBase.cs
@@ -30,16 +30,22 @@ public abstract class LightClientBase<TContract> : IDisposable where TContract :
 
         #region Constructors
         /// <summary>
-        /// Initializes a new instance of the <see cref="T:LightClientBase{TContract}"/> class (creates the channel factory)
+        /// Initializes a new instance of the <see cref="T:LightClientBase{TContract}" /> class (creates the channel factory)
         /// from a remote address. The constructor will try to resolve the binding from the schema in the given remote address from the current DI container.
         /// </summary>
         /// <param name="remoteAddress">
         /// The remote address of the service.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected LightClientBase(
-            string remoteAddress)
-            : this(null, remoteAddress)
+            string remoteAddress,
+            string messagingPattern = null)
+            : this(null, remoteAddress, messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(!string.IsNullOrWhiteSpace(remoteAddress), "remoteAddress");
             Contract.Ensures(ChannelFactory != null);
@@ -59,10 +65,16 @@ protected LightClientBase(
         /// The remote address. If the remote address is <see langword="null" /> or empty
         /// the constructor will try to use the address in the endpoint configuration.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected LightClientBase(
             string endpointConfigurationName,
-            string remoteAddress)
+            string remoteAddress,
+            string messagingPattern = null)
         {
             Contract.Requires<ArgumentException>(
                 !string.IsNullOrWhiteSpace(endpointConfigurationName) ||
@@ -90,7 +102,7 @@ protected LightClientBase(
                 ChannelFactory = new ChannelFactory<TContract>(binding, remoteEndpoint);
             }
 
-            ConfigureBinding(binding);
+            ConfigureBinding(binding, messagingPattern);
         }
 
         /// <summary>
@@ -106,11 +118,17 @@ protected LightClientBase(
         /// If the identity type is <see cref="ServiceIdentity.Upn" /> - use the UPN of the service identity; if <see cref="ServiceIdentity.Spn" /> - use the SPN and if
         /// <see cref="ServiceIdentity.Rsa" /> - use the RSA key.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected LightClientBase(
             string remoteAddress,
             ServiceIdentity identityType,
-            string identity)
+            string identity,
+            string messagingPattern = null)
         {
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
             Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(remoteAddress), "The argument \"remoteAddress\" cannot be null, empty or consist of whitespace characters only.");
@@ -142,7 +160,7 @@ protected LightClientBase(
                                     binding,
                                     new EndpointAddress(remoteUri, EndpointIdentityFactory.CreateEndpointIdentity(identityType, identity)));
 
-            ConfigureBinding(ChannelFactory.Endpoint.Binding);
+            ConfigureBinding(ChannelFactory.Endpoint.Binding, messagingPattern);
         }
 
         /// <summary>
@@ -153,11 +171,17 @@ protected LightClientBase(
         /// Type of the identity: can be <see cref="ServiceIdentity.Certificate" />, <see cref="ServiceIdentity.Dns" /> or <see cref="ServiceIdentity.Rsa" />.
         /// </param>
         /// <param name="certificate">The identifying certificate.</param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected LightClientBase(
             string remoteAddress,
             ServiceIdentity identityType,
-            X509Certificate2 certificate)
+            X509Certificate2 certificate,
+            string messagingPattern = null)
         {
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
             Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(remoteAddress), "The argument \"remoteAddress\" cannot be null, empty or consist of whitespace characters only.");
@@ -184,7 +208,7 @@ protected LightClientBase(
                                     binding,
                                     new EndpointAddress(remoteUri, EndpointIdentityFactory.CreateEndpointIdentity(identityType, certificate)));
 
-            ConfigureBinding(ChannelFactory.Endpoint.Binding);
+            ConfigureBinding(ChannelFactory.Endpoint.Binding, messagingPattern);
         }
 
         /// <summary>
@@ -201,12 +225,18 @@ protected LightClientBase(
         /// If the identity type is <see cref="ServiceIdentity.Upn" /> - use the UPN of the service identity; if <see cref="ServiceIdentity.Spn" /> - use the SPN and if
         /// <see cref="ServiceIdentity.Rsa" /> - use the RSA key.
         /// </param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected LightClientBase(
             Binding binding,
             string remoteAddress,
             ServiceIdentity identityType,
-            string identity)
+            string identity,
+            string messagingPattern = null)
         {
             Contract.Requires<ArgumentNullException>(binding != null, nameof(binding));
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
@@ -232,7 +262,7 @@ protected LightClientBase(
                                     binding,
                                     new EndpointAddress(remoteUri, EndpointIdentityFactory.CreateEndpointIdentity(identityType, identity)));
 
-            ConfigureBinding(ChannelFactory.Endpoint.Binding);
+            ConfigureBinding(ChannelFactory.Endpoint.Binding, messagingPattern);
         }
 
         /// <summary>
@@ -244,12 +274,18 @@ protected LightClientBase(
         /// Type of the identity: can be <see cref="ServiceIdentity.Certificate" /> or <see cref="ServiceIdentity.Rsa" />.
         /// </param>
         /// <param name="certificate">The identifying certificate.</param>
+        /// <param name="messagingPattern">
+        /// The messaging pattern defining the configuration of the connection. If <see langword="null"/>, empty or whitespace characters only, 
+        /// the constructor will try to resolve the pattern from the interface's attribute <see cref="MessagingPatternAttribute"/> if present,
+        /// otherwise will apply the default messaging pattern fro the transport.
+        /// </param>
         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
         protected LightClientBase(
             Binding binding,
             string remoteAddress,
             ServiceIdentity identityType,
-            X509Certificate2 certificate)
+            X509Certificate2 certificate,
+            string messagingPattern = null)
         {
             Contract.Requires<ArgumentNullException>(binding != null, nameof(binding));
             Contract.Requires<ArgumentNullException>(remoteAddress != null, nameof(remoteAddress));
@@ -273,19 +309,24 @@ protected LightClientBase(
                                     binding,
                                     new EndpointAddress(remoteUri, EndpointIdentityFactory.CreateEndpointIdentity(identityType, certificate)));
 
-            ConfigureBinding(ChannelFactory.Endpoint.Binding);
+            ConfigureBinding(ChannelFactory.Endpoint.Binding, messagingPattern);
         }
         #endregion
 
-        void ConfigureBinding(Binding binding)
+        void ConfigureBinding(
+            Binding binding,
+            string messagingPattern)
         {
             Contract.Requires<ArgumentNullException>(binding != null, nameof(binding));
 
-            // try to get the messaging pattern from the client
-            var messagingPattern = GetType().GetMessagingPattern();
-
             if (string.IsNullOrWhiteSpace(messagingPattern))
-                messagingPattern = typeof(TContract).GetMessagingPattern();
+            {
+                // try to get the messaging pattern from the client
+                messagingPattern = GetType().GetMessagingPattern();
+
+                if (string.IsNullOrWhiteSpace(messagingPattern))
+                    messagingPattern = typeof(TContract).GetMessagingPattern();
+            }
 
             // resolve the configurator
             var configurator = ServiceLocator.Current.GetInstance<BindingConfigurator>(messagingPattern);
@@ -324,7 +365,7 @@ public bool IsDisposed
         /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
         /// </summary>
         /// <remarks>Invokes the protected virtual <see cref="M:Dispose(bool)"/>.</remarks>
-        [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification="It is correct.")]
+        [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "It is correct.")]
         public void Dispose()
         {
             if (Interlocked.Exchange(ref _disposed, 1) != 0)
diff --git a/Aspects/Wcf/CustomDataContext.cs b/Aspects/Wcf/CustomDataContext.cs
index ebfaec6..7d26986 100644
--- a/Aspects/Wcf/CustomDataContext.cs
+++ b/Aspects/Wcf/CustomDataContext.cs
@@ -2,10 +2,15 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Globalization;
+using System.IO;
+using System.Net;
 using System.Reflection;
 using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
 using System.ServiceModel;
 using System.ServiceModel.Channels;
+using System.ServiceModel.Web;
+using System.Text;
 using Microsoft.Practices.EnterpriseLibrary.Validation.Validators;
 
 namespace vm.Aspects.Wcf
@@ -18,11 +23,12 @@ namespace vm.Aspects.Wcf
     /// The type of the context. Must be either marked with <see cref="T:System.Runtime.Serialization.DataContractAttribute"/> or it must be serializable type.
     /// The size of the type plus the size of the other headers are limited by the property <c>MaxBufferSize</c>.
     /// </typeparam>
-    [DataContract(Namespace="vm.Aspects.Wcf")]
+    [DataContract(Namespace = "vm.Aspects.Wcf")]
     public class CustomDataContext<T>
     {
         static string _name;
         static string _namespace;
+        static string _webHeaderName;
         static object _syncInitialize = new object();
 
         /// <summary>
@@ -57,6 +63,22 @@ public string Namespace
             }
         }
 
+        /// <summary>
+        /// Gets the name of the web header.
+        /// </summary>
+        public string WebHeaderName
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<string>() != null);
+
+                if (_webHeaderName == null)
+                    Initialize();
+
+                return _webHeaderName;
+            }
+        }
+
         /// <summary>
         /// Initializes the name and namespace of the custom context.
         /// </summary>
@@ -83,14 +105,18 @@ static void Initialize()
                 // if the namespace and the name of the context are not specified explicitly in the attribute,
                 // assume the namespace and the name of the context type.
                 _name = dataContractAttribute!=null &&
-                        !string.IsNullOrWhiteSpace(dataContractAttribute.Name) 
-                                ? dataContractAttribute.Name 
+                        !string.IsNullOrWhiteSpace(dataContractAttribute.Name)
+                                ? dataContractAttribute.Name
                                 : typeof(T).Name;
 
                 _namespace = dataContractAttribute!=null &&
-                             !string.IsNullOrWhiteSpace(dataContractAttribute.Namespace) 
-                                ? dataContractAttribute.Namespace 
+                             !string.IsNullOrWhiteSpace(dataContractAttribute.Namespace)
+                                ? dataContractAttribute.Namespace
                                 : typeof(T).Namespace;
+
+                _webHeaderName = string.IsNullOrWhiteSpace(_namespace)
+                                    ? _name
+                                    : string.Format(CultureInfo.InvariantCulture, "{0}-{1}", _namespace, _name);
             }
         }
 
@@ -129,7 +155,7 @@ public CustomDataContext()
         /// <item>Could not obtain the current operation context. It must be invoked from within a WCF service or OperationContextScope.</item>
         /// <item>A header with this namespace and name already exists in the message.</item>
         /// </list></exception>
-        [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes", Justification="It's OK here.")]
+        [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes", Justification = "It's OK here.")]
         public static CustomDataContext<T> Current
         {
             // get the custom header from the incoming message which is in the current operation context (called by the services)
@@ -142,40 +168,67 @@ public static CustomDataContext<T> Current
                     return null;
 
                 // find the header by namespace and name
-                var index = OperationContext.Current.IncomingMessageHeaders.FindHeader(_name, _namespace);
+                if (WebOperationContext.Current != null)
+                {
+                    var serialized = WebOperationContext.Current.IncomingRequest.Headers.Get(_webHeaderName);
 
-                if (index == -1)
-                    return null;
+                    if (string.IsNullOrWhiteSpace(serialized))
+                        return null;
+
+                    using (var stream = new MemoryStream(Encoding.Unicode.GetBytes(serialized)))
+                    {
+                        var serializer = GetJsonSerializer();
+
+                        return new CustomDataContext<T>((T)serializer.ReadObject(stream));
+                    }
+                }
                 else
-                    return OperationContext.Current.IncomingMessageHeaders.GetHeader<CustomDataContext<T>>(index);
+                {
+                    var index = OperationContext.Current.IncomingMessageHeaders.FindHeader(_name, _namespace);
+
+                    if (index == -1)
+                        return null;
+                    else
+                        return OperationContext.Current.IncomingMessageHeaders.GetHeader<CustomDataContext<T>>(index);
+                }
             }
 
             set
             {
                 // put the custom header into the outgoing message which is in the current operation context (called by the clients)
                 Contract.Requires<ArgumentNullException>(value != null, nameof(value));
-                Contract.Requires<ArgumentException>(!String.IsNullOrWhiteSpace(value.Name));
+                Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(value.Name));
+                Contract.Requires<InvalidOperationException>(OperationContext.Current != null, "The current thread does not have operation context.");
 
                 // make sure the header is initialized.
                 Initialize();
 
-                var opContext = OperationContext.Current;
-
-                if (opContext == null)
-                    throw new InvalidOperationException("The current thread does not have operation context.");
-
                 //make sure that there are no multiple CustomContextData<T> objects.
-                var index = opContext.OutgoingMessageHeaders.FindHeader(_name, _namespace);
-
-                if (index != -1)
-                    throw new InvalidOperationException(
-                        string.Format(
-                            CultureInfo.InvariantCulture,
-                            "A header {1}/{0} already exists in the message.",
-                            _name,
-                            _namespace));
+                if (WebOperationContext.Current != null)
+                {
+                    if (WebOperationContext.Current.OutgoingRequest.Headers.Get(_webHeaderName) == null)
+                        value.AddToHeaders(WebOperationContext.Current.OutgoingRequest.Headers);
+                    else
+                        throw new InvalidOperationException(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "A header {0} already exists in the message.",
+                                _webHeaderName));
+                }
+                else
+                {
+                    var index = OperationContext.Current.OutgoingMessageHeaders.FindHeader(_name, _namespace);
 
-                value.AddToHeaders(opContext.OutgoingMessageHeaders);
+                    if (index == -1)
+                        value.AddToHeaders(OperationContext.Current.OutgoingMessageHeaders);
+                    else
+                        throw new InvalidOperationException(
+                            string.Format(
+                                CultureInfo.InvariantCulture,
+                                "A header {1}/{0} already exists in the message.",
+                                _name,
+                                _namespace));
+                }
             }
         }
 
@@ -194,5 +247,37 @@ public void AddToHeaders(
                 new MessageHeader<CustomDataContext<T>>(this)
                         .GetUntypedHeader(Name, Namespace));
         }
+
+        /// <summary>
+        /// Adds the value of the context to the current outgoing web message headers.
+        /// </summary>
+        /// <param name="headers">The headers collection.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if <paramref name="headers"/> is <see langword="null"/></exception>
+        public void AddToHeaders(
+            WebHeaderCollection headers)
+        {
+            Contract.Requires<ArgumentNullException>(headers != null, nameof(headers));
+            Contract.Requires<InvalidOperationException>(!string.IsNullOrWhiteSpace(Name), "Property Name");
+
+            using (var stream = new MemoryStream())
+            {
+                var serializer = GetJsonSerializer();
+
+                serializer.WriteObject(stream, Value);
+                headers.Add(_webHeaderName, Encoding.Default.GetString(stream.ToArray()));
+            }
+        }
+
+        static DataContractJsonSerializer GetJsonSerializer()
+        {
+            return new DataContractJsonSerializer(
+                            typeof(T),
+                            new DataContractJsonSerializerSettings
+                            {
+                                DateTimeFormat            = new DateTimeFormat("o", CultureInfo.InvariantCulture),
+                                EmitTypeInformation       = EmitTypeInformation.Never,
+                                UseSimpleDictionaryFormat = true,
+                            });
+        }
     }
 }
diff --git a/Aspects/Wcf/DataContracts/DataTransferObject.cs b/Aspects/Wcf/DataContracts/DataTransferObject.cs
index 4d58462..908424f 100644
--- a/Aspects/Wcf/DataContracts/DataTransferObject.cs
+++ b/Aspects/Wcf/DataContracts/DataTransferObject.cs
@@ -15,7 +15,7 @@ namespace vm.Aspects.Wcf.DataContracts
     /// WCF DTO's base class. Takes care of the forward and backward compatibility of the DTO-s and standardizes on <see cref="IValidatable"/>.
     /// Can be easily used also in a non-WCF context.
     /// </summary>
-    [DataContract(Namespace = "urn:service:vm.Aspects.Wcf.DataContracts", IsReference = true)]
+    [DataContract(Namespace = "urn:service:vm.Aspects.Wcf.DataContracts")]
     public abstract class DataTransferObject : IExtensibleDataObject, IValidatable
     {
         #region IExtensibleDataObject Members
diff --git a/Aspects/Wcf/FaultContracts/BusinessFault.cs b/Aspects/Wcf/FaultContracts/BusinessFault.cs
index 524c9c6..a89b3e2 100644
--- a/Aspects/Wcf/FaultContracts/BusinessFault.cs
+++ b/Aspects/Wcf/FaultContracts/BusinessFault.cs
@@ -15,7 +15,7 @@ public class BusinessFault : Fault
         /// Initializes a new instance of the <see cref="BusinessFault"/> class.
         /// </summary>
         public BusinessFault()
-            : base(HttpStatusCode.Forbidden)
+            : base(HttpStatusCode.Conflict)
         {
         }
 
diff --git a/Aspects/Wcf/FaultContracts/Fault.cs b/Aspects/Wcf/FaultContracts/Fault.cs
index 9b16328..6b793a6 100644
--- a/Aspects/Wcf/FaultContracts/Fault.cs
+++ b/Aspects/Wcf/FaultContracts/Fault.cs
@@ -22,6 +22,18 @@ namespace vm.Aspects.Wcf.FaultContracts
     public partial class Fault
     {
         #region Properties
+        /// <summary>
+        /// Gets or sets the full type name of the fault for easier analysis (incl. deserialization) of the fault on the front end.
+        /// IMPORTANT: Any change in the name or namespace of the faults will be potentially breaking changes in the API-s.
+        /// </summary>
+        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "value", Justification = "WCF will complain.")]
+        [DataMember]
+        public string FaultType
+        {
+            get { return GetType().AssemblyQualifiedName; }
+            set { }
+        }
+
         /// <summary>
         /// Gets or sets the handling instance ID.
         /// <c>PostHandlingAction.ThrowNewException</c> causes the exception handling application block to throw a new exception of type 
@@ -130,34 +142,38 @@ public Exception InnerException
         /// </summary>
         [DataMember]
         public string Source { get; set; }
+#endif
 
         #region Constructor
         /// <summary>
         /// Initializes a new instance with some default data in DEBUG mode only.
         /// </summary>
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
+        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
         public Fault()
+            : this(HttpStatusCode.InternalServerError)
         {
-            var process = Process.GetCurrentProcess();
-
-            ProcessId   = process.Id;
-            ProcessName = process.ProcessName;
-            ThreadId    = Thread.CurrentThread.ManagedThreadId;
-            MachineName = Environment.MachineName;
-            User        = Environment.UserName;
         }
         #endregion
-#endif
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Fault"/> class.
         /// </summary>
         /// <param name="httpStatusCode">The HTTP status code.</param>
-        protected Fault(HttpStatusCode httpStatusCode)
+        public Fault(HttpStatusCode httpStatusCode)
         {
-            Contract.Requires<ArgumentException>(httpStatusCode >= (HttpStatusCode)400, "The faults describe exceptional fault situations and should have status greater or equal to 400 (HTTP 400 Bad request.)");
+            Contract.Requires<ArgumentException>(httpStatusCode >= (HttpStatusCode)400, "The faults describe exceptional fault situations and should have status code equal to or greater than 400 (HTTP 400 Bad request.)");
 
             HttpStatusCode = httpStatusCode;
+
+#if DEBUG
+            var process = Process.GetCurrentProcess();
+
+            ProcessId   = process.Id;
+            ProcessName = process.ProcessName;
+            ThreadId    = Thread.CurrentThread.ManagedThreadId;
+            MachineName = Environment.MachineName;
+            User        = Environment.UserName;
+#endif
         }
 
         #region Methods
@@ -197,12 +213,5 @@ public static string GetHttpStatusDescription(
             return _httpStatusDescriptions.TryGetValue(code, out description) ? description : null;
         }
         #endregion
-
-        [ContractInvariantMethod]
-        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Required for code contracts.")]
-        void ObjectInvariant()
-        {
-            Contract.Invariant(InnerException == null);
-        }
     }
 }
diff --git a/Aspects/Wcf/FaultContracts/IOFault.cs b/Aspects/Wcf/FaultContracts/IOFault.cs
index 312e260..cd906c6 100644
--- a/Aspects/Wcf/FaultContracts/IOFault.cs
+++ b/Aspects/Wcf/FaultContracts/IOFault.cs
@@ -15,7 +15,7 @@ public class IOFault : Fault
         /// Initializes a new instance of the <see cref="IOFault"/> class.
         /// </summary>
         public IOFault()
-            : base(HttpStatusCode.Forbidden)
+            : base(HttpStatusCode.Conflict)
         {
         }
 
diff --git a/Aspects/Wcf/FaultContracts/InvalidOperationFault.cs b/Aspects/Wcf/FaultContracts/InvalidOperationFault.cs
index 23a488a..b1f50b7 100644
--- a/Aspects/Wcf/FaultContracts/InvalidOperationFault.cs
+++ b/Aspects/Wcf/FaultContracts/InvalidOperationFault.cs
@@ -13,7 +13,7 @@ public sealed class InvalidOperationFault : Fault
         /// Initializes a new instance of the <see cref="InvalidOperationFault"/> class.
         /// </summary>
         public InvalidOperationFault()
-            : base(HttpStatusCode.Forbidden)
+            : base(HttpStatusCode.Conflict)
         {
         }
     }
diff --git a/Aspects/Wcf/FaultContracts/Metadata/FaultMetadata.cs b/Aspects/Wcf/FaultContracts/Metadata/FaultMetadata.cs
index cfbd5da..90ea548 100644
--- a/Aspects/Wcf/FaultContracts/Metadata/FaultMetadata.cs
+++ b/Aspects/Wcf/FaultContracts/Metadata/FaultMetadata.cs
@@ -2,16 +2,19 @@
 
 namespace vm.Aspects.Wcf.FaultContracts.Metadata
 {
-    [Dump(DumpNullValues=ShouldDump.Skip)]
+    [Dump(DumpNullValues = ShouldDump.Skip)]
     abstract class FaultMetadata
     {
         [Dump(0)]
+        public object FaultType { get; set; }
+
+        [Dump(1)]
         public object HandlingInstanceId { get; set; }
 
-        [Dump(1, ValueFormat="\n{0}")]
+        [Dump(2, ValueFormat = "\n{0}")]
         public object Message { get; set; }
 
-        [Dump(2, ValueFormat="\n{0}")]
+        [Dump(3, ValueFormat = "\n{0}")]
         public object InnerExceptionsMessages { get; set; }
 
 #if DEBUG
diff --git a/Aspects/Wcf/FaultContracts/ProtocolExceptionToWebFaultResolver.cs b/Aspects/Wcf/FaultContracts/ProtocolExceptionToWebFaultResolver.cs
new file mode 100644
index 0000000..e7b9cb6
--- /dev/null
+++ b/Aspects/Wcf/FaultContracts/ProtocolExceptionToWebFaultResolver.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Contracts;
+using System.Globalization;
+using System.IO;
+using System.Net;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
+using System.ServiceModel;
+using System.Text.RegularExpressions;
+
+namespace vm.Aspects.Wcf.FaultContracts
+{
+    /// <summary>
+    /// Contains a utility method for translating <see cref="ProtocolException"/>-s to <see cref="Fault"/>-s.
+    /// </summary>
+    public static class ProtocolExceptionToWebFaultResolver
+    {
+        const string _rexFaultType = @",\s*""FaultType""\s*:\s*""(?<type>[^""]+)"",";
+
+        static Lazy<Regex> _faultType = new Lazy<Regex>(() => new Regex(_rexFaultType, RegexOptions.Compiled));
+
+        static Regex RexFaultType => _faultType.Value;
+
+        /// <summary>
+        /// Resolves protocol exceptions to <see cref="Fault"/>-s.
+        /// </summary>
+        /// <param name="exception">The exception to resolve.</param>
+        /// <param name="serializedFault">The serialized fault string contained in the <paramref name="exception"/>.</param>
+        /// <returns>The resolved <see cref="Fault"/> instance or <see langword="null"/>.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Here we handle the specific exception.")]
+        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "1#", Justification = "We need two results here.")]
+        public static Fault Resolve(
+            ProtocolException exception,
+            out string serializedFault)
+        {
+            Contract.Requires<ArgumentNullException>(exception != null, nameof(exception));
+
+            serializedFault = null;
+
+            try
+            {
+                var wx = exception.InnerException as WebException;
+
+                if (wx == null)
+                    return null;
+
+                var stream = wx.Response.GetResponseStream();
+                var reader = new StreamReader(stream, true);
+
+                serializedFault = reader.ReadToEnd();
+                stream.Seek(0, SeekOrigin.Begin);
+
+                var matchType = RexFaultType.Match(serializedFault);
+
+                if (!matchType.Success)
+                    return null;
+
+                var faultType = Type.GetType(matchType.Groups["type"].Value, false);
+
+                if (faultType == null)
+                    return null;
+
+                var serializer = new DataContractJsonSerializer(
+                                            faultType,
+                                            new DataContractJsonSerializerSettings
+                                            {
+                                                DateTimeFormat            = new DateTimeFormat("o", CultureInfo.InvariantCulture),
+                                                EmitTypeInformation       = EmitTypeInformation.Never,
+                                                UseSimpleDictionaryFormat = true,
+                                            });
+                return serializer.ReadObject(stream) as Fault;
+            }
+            catch (SerializationException)
+            {
+                return null;
+            }
+        }
+    }
+}
diff --git a/Aspects/Wcf/ServicePolicies/ServiceCallTraceCallHandler.cs b/Aspects/Wcf/ServicePolicies/ServiceCallTraceCallHandler.cs
index f152421..e0a4944 100644
--- a/Aspects/Wcf/ServicePolicies/ServiceCallTraceCallHandler.cs
+++ b/Aspects/Wcf/ServicePolicies/ServiceCallTraceCallHandler.cs
@@ -61,7 +61,7 @@ public ServiceCallTraceCallHandler(
         /// Creates the call data.
         /// </summary>
         /// <returns>CallData.</returns>
-        protected virtual CallData CreateCallData()
+        protected override CallData CreateCallData()
         {
             return new ServiceCallData();
         }
@@ -87,7 +87,8 @@ protected override CallData GetCallData(
                     var contextType = typeof(CustomDataContext<>).MakeGenericType(customContextTypeAttribute.CustomDataContextType);
                     var context = contextType.GetProperty("Current").GetValue(null, null);
 
-                    callData.CustomContext = contextType.GetProperty("Value").GetValue(context, null);
+                    if (context != null)
+                        callData.CustomContext = contextType.GetProperty("Value").GetValue(context, null);
                 }
             }
 
@@ -178,7 +179,6 @@ void DumpCustomContext(
         {
             Contract.Requires<ArgumentNullException>(writer != null, nameof(writer));
             Contract.Requires<ArgumentNullException>(callData != null, nameof(callData));
-            //Contract.Requires<ArgumentException>(callData is ServiceCallData, "callData must be of type ServiceCallData");
 
             if (!IncludeCustomContext)
                 return;
diff --git a/Aspects/Wcf/vm.Aspects.Wcf.csproj b/Aspects/Wcf/vm.Aspects.Wcf.csproj
index 8c64203..f18e114 100644
--- a/Aspects/Wcf/vm.Aspects.Wcf.csproj
+++ b/Aspects/Wcf/vm.Aspects.Wcf.csproj
@@ -320,6 +320,7 @@
     <Compile Include="FaultContracts\ObjectIdentifierNotUniqueFault.cs" />
     <Compile Include="FaultContracts\ObjectNotFoundFault.cs" />
     <Compile Include="FaultContracts\PathTooLongFault.cs" />
+    <Compile Include="FaultContracts\ProtocolExceptionToWebFaultResolver.cs" />
     <Compile Include="FaultContracts\RepeatableOperationFault.cs" />
     <Compile Include="FaultContracts\SerializationFault.cs" />
     <Compile Include="FaultContracts\UnauthorizedAccessFault.cs" />
diff --git a/Aspects/vm.Aspects.csproj b/Aspects/vm.Aspects.csproj
index 7167729..458db96 100644
--- a/Aspects/vm.Aspects.csproj
+++ b/Aspects/vm.Aspects.csproj
@@ -234,6 +234,7 @@
     <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.ServiceModel" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -300,6 +301,9 @@
     <Compile Include="ResolveNameAttribute.cs" />
     <Compile Include="Security\CertificateFactory.cs" />
     <Compile Include="SemanticVersion.cs" />
+    <Compile Include="SemanticVersion.Metadata.cs">
+      <DependentUpon>SemanticVersion.cs</DependentUpon>
+    </Compile>
     <Compile Include="Threading\AsyncProducerConsumerCollection.cs" />
     <Compile Include="Threading\ReaderSlimSync.cs" />
     <Compile Include="Threading\ReaderWriterLockSlimExtensions.cs" />