Force WCF Rest client to use Json deserializer regardless of content-type

Question

How to force WCF Rest client to use Json deserializer regardless of content-type?

I am invoking a REST based web service through WCF.

The service returns JSON body, but has content-type "Application/xml". The WCF framework is now giving me the XmlException.

public class MessageFormatter : IClientMessageFormatter
{
    private readonly IClientMessageFormatter _formatter;

    public MessageFormatter(IClientMessageFormatter formatter)
    {
        _formatter = formatter;
    }

    public object DeserializeReply(System.ServiceModel.Channels.Message message, object[] parameters)
    {
        return _formatter.DeserializeReply(message, parameters);
    }
}

that _formatter.DeserializeReply is throwing XmlException. I can't find any example anywhere to force json deserialization on reply.

Edit - The "message" object when moused over is throwing "{... Error reading body: System.Xml.XmlException: The data at the root level is invalid. Line 1, position 1. ...}"

That same object in another one of my project that communicate with a different REST service (Picasa web services) has a what seems like a xml serialised version of JSON object?? So the problem seems further up the stream. I need to find where this object is originating from. I'll go play around with MessageEncoder class.

Edit - (Adding more info)

public class MyBinding : WebHttpBinding
{
    public MyBinding(WebHttpSecurityMode mode)
        : base(mode)
    {

    }

    public override BindingElementCollection CreateBindingElements()
    {
        var result = base.CreateBindingElements();

        var replacements = result.OfType<MessageEncodingBindingElement>().ToList();
        foreach (var messageEncodingBindingElement in replacements)
        {
            var index = result.IndexOf(messageEncodingBindingElement);
            result.Remove(messageEncodingBindingElement);
            result.Insert(index, new MyMessageEncodingBindingElement(messageEncodingBindingElement));
        }

        return result;
    }
}

public class MyMessageEncodingBindingElement : MessageEncodingBindingElement
{
    private readonly MessageEncodingBindingElement _element;

    public MyMessageEncodingBindingElement(MessageEncodingBindingElement element)
    {
        _element = element;
    }

    public override BindingElement Clone()
    {
        var result = _element.Clone();

        if (result is MessageEncodingBindingElement)
            return new MyMessageEncodingBindingElement(result as MessageEncodingBindingElement);

        return result;
    }

    public override MessageEncoderFactory CreateMessageEncoderFactory()
    {
        return new MyMessageEncoderFactory(_element.CreateMessageEncoderFactory());
    }
}

The method CreateMessageEncoderFactory() is never called even when the constructor and Clone method are hit when breakpoints are set. Any help? I'm trying to set a custom MessageEncoder and MessageEncoderFactory class to modify the instantiation process of the Message object.

Answer 1

You can use a WebContentTypeMapper for that. That's a property of the WebHttpBinding, and you can customize how the deserialization will be done by the encoder from that binding, including forcing it to always use the JSON deserializer, regardless of the incoming message's Content-Type. The code below shows how this can be done.

public class StackOverflow_13225272
{
    [DataContract]
    public class Person
    {
        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public int Age { get; set; }

        public override string ToString()
        {
            return string.Format("Person[Name={0},Age={1}]", Name, Age);
        }
    }
    [ServiceContract]
    public interface ITest
    {
        [WebGet(ResponseFormat = WebMessageFormat.Json)]
        Person GetPerson(string responseContentType);
    }

    public class Service : ITest
    {
        public Person GetPerson(string responseContentType)
        {
            WebOperationContext.Current.OutgoingResponse.ContentType = responseContentType;
            return new Person { Name = "John Doe", Age = 29 };
        }
    }
    class AllJsonContentTypeMapper : WebContentTypeMapper
    {
        public override WebContentFormat GetMessageFormatForContentType(string contentType)
        {
            return WebContentFormat.Json;
        }
    }
    public static void Test()
    {
        string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
        WebServiceHost host = new WebServiceHost(typeof(Service), new Uri(baseAddress));
        host.Open();
        Console.WriteLine("Host opened");

#if USE_NETFX4
        // This works on .NET 4.0 and beyond
        WebHttpBinding binding = new WebHttpBinding();
        binding.ContentTypeMapper = new AllJsonContentTypeMapper();
#else
        // This works on .NET 3.5
        CustomBinding binding = new CustomBinding(new WebHttpBinding());
        binding.Elements.Find<WebMessageEncodingBindingElement>().ContentTypeMapper = new AllJsonContentTypeMapper();
        ChannelFactory<ITest> factory = new ChannelFactory<ITest>(binding, new EndpointAddress(baseAddress));
#endif

        ChannelFactory<ITest> factory = new ChannelFactory<ITest>(binding, new EndpointAddress(baseAddress));
        factory.Endpoint.Behaviors.Add(new WebHttpBehavior());
        ITest proxy = factory.CreateChannel();

        Console.WriteLine("With JSON: {0}", proxy.GetPerson("application/json"));
        Console.WriteLine("With XML: {0}", proxy.GetPerson("application/xml"));

        Console.Write("Press ENTER to close the host");
        Console.ReadLine();
        host.Close();
    }
}

Answer 2

This might work.

public class ForceJsonClientMessageFormatter : IClientMessageFormatter
{
    private readonly DataContractJsonSerializer _jsonSerializer;

    public ForceJsonClientMessageFormatter(Type responseType)
    {
        _jsonSerializer = new DataContractJsonSerializer(responseType);
    }

    public Message SerializeRequest(MessageVersion messageVersion, object[] parameters)
    {
        throw new NotImplementedException("This client message formatter is for replies only!");
    }

    public object DeserializeReply(Message message, object[] parameters)
    {
        string messageBody = message.GetBody<string>();

        using (MemoryStream messageStream = new MemoryStream(Encoding.UTF8.GetBytes(messageBody)))
        {
            messageStream.Seek(0, SeekOrigin.Begin);
            object deserializedObject = _jsonSerializer.ReadObject(messageStream);
            return deserializedObject;
        }
    }
}

public class ForceJsonWebHttpBehavior : WebHttpBehavior
{
    protected override IClientMessageFormatter GetReplyClientFormatter(OperationDescription operationDescription, ServiceEndpoint endpoint)
    {
        return new ForceJsonClientMessageFormatter(operationDescription.Messages[1].Body.ReturnValue.Type);
    }
}

Answer 3

I haven't tried it, but I think this will work. You can create a custom IClientMessageFormatter which overwrites the message format to Json, wrap that in a behavior, and then apply that behavior to your client endpoint configuration.

public class ForceJsonClientMessageFormatterDecorator : IClientMessageFormatter
{
    private readonly IClientMessageFormatter _decoratedFormatter;
    public ForceJsonClientMessageFormatterDecorator(IClientMessageFormatter decoratedFormatter)
    {
        _decoratedFormatter = decoratedFormatter;
    }

    public object DeserializeReply(Message message, object[] parameters)
    {
        message.Properties[WebBodyFormatMessageProperty.Name] = new WebBodyFormatMessageProperty(WebContentFormat.Json);
        return _decoratedFormatter.DeserializeReply(message, parameters);
    }

    public Message SerializeRequest(MessageVersion messageVersion, object[] parameters)
    {
        return _decoratedFormatter.SerializeRequest(messageVersion, parameters);
    }
}

public class ForceJsonWebHttpBehavior : WebHttpBehavior
{
    protected override IClientMessageFormatter GetReplyClientFormatter(OperationDescription operationDescription, ServiceEndpoint endpoint)
    {
        IClientMessageFormatter decoratedFormatter = base.GetReplyClientFormatter(operationDescription, endpoint);
        return new ForceJsonClientMessageFormatterDecorator(decoratedFormatter);
    }
}