Passing exceptions between two C# programs using JSON

Replace your exception handling with following code block.

else
{
    var response = await response.Content.ReadAsStringAsync();
    var exception = JsonConvert.DeserializeObject<Exception>(response);
    // your handling logic here
    Console.WriteLine(exception);
}

So if service threw new NotImplementedException("I haz error!"), above would print out System.NotImplementedException: I haz error!.

Here's a quick, stand-alone example using MVVMLight and JSON.net. Say you have sender as

public class Sender
{
    public Sender()
    {
        Messenger.Default.Register<NotificationMessage>(this, message =>
            {
                if ((Type)message.Target == typeof(Sender))
                   GotResponse(message.Notification);
            });    
    }

    public void SendRequest(string request)
    {
        Console.WriteLine("sending:{0}", request);
        Messenger.Default.Send(
            new NotificationMessage(this, typeof(Receiver), request));
    }

    private void GotResponse(string response)
    {
        Console.WriteLine("received:{0}", response);
        if (response.Equals("ok"))
            return;

        Exception exception = JsonConvert.DeserializeObject<Exception>(response);
        Console.WriteLine("exception:{0}", exception);

        try
        {
            throw exception;
        }
        catch (Exception e)
        {
            Console.WriteLine("Indeed, it was {0}", e);
        }
    }
}

and receiver as

public class Receiver
{
    public Receiver()
    {
        Messenger.Default.Register<NotificationMessage>(this, message =>
            {
                if ((Type)message.Target == typeof(Receiver))
                    GotRequest(message.Notification);
            }); 
    }

    public void SendResponse(string response)
    {
        Messenger.Default.Send(new NotificationMessage(this, typeof(Sender), response));
    }

    public void GotRequest(string request)
    {
        string response = !string.IsNullOrWhiteSpace(request) ? 
                          "ok" : 
                          JsonConvert.SerializeObject(new NotImplementedException("I haz error!"));

        SendResponse(response);
    }
}

then following "activation"

var sender = new Sender();
var receiver = new Receiver();
sender.SendRequest("my request");
sender.SendRequest(null);

would print out

sending:my request
received:ok

sending:
received: {"ClassName":"System.NotImplementedException", "Message":"...","WatsonBuckets":null}

exception:System.NotImplementedException: I haz error!

Indeed, it was System.NotImplementedException: I haz error! at WpfApplication1.View.Sender.GotResponse(String response) in...

First of all to be able to deserialize exception JSON I was forced to add an extra constructor to ConnectionErrorException class:

public class ConnectionErrorException : Exception
{
    // ... rest of the code

    protected ConnectionErrorException(SerializationInfo info, StreamingContext context) 
        : base(info, context)
    {
    }
}

This is a known issue. Check this question for example.

Next I would read the value of ClassName property first and then according to the value would deserialize it to desired type. I think it will be a good idea to create some helper class for that:

public static class JsonHelper
{
    public static bool IsInstanceOf<T>(this JsonObject jsonObject)
    {
        if (jsonObject == null || !jsonObject.ContainsKey("ClassName"))
        {
            return false;
        }

        return jsonObject["ClassName"] == typeof(T).FullName;
    }
}

And then your code might look like that:

var jsonObject = JsonObject.Parse(json);
if(jsonObject.IsInstanceOf<ConnectionErrorException>())
{
    var connectionErrorException = 
        JsonConvert.DeserializeObject<ConnectionErrorException>(json);
}

You can keep you exceptions to a C# dynamic Object then serialize it to JSON and then return it from your windows service. Again on the Web API you deserialize that JSON and keep into a dynamic object. In this way you don't have to bother about the actual Type of the exception. On any exception you can just throw it away. If you want to know the actual type of the exception then you can write you code like this where tempData is the dynamic object after deserializiation:

Type exceptionType = ((ObjectHandle)tempData).Unwrap().GetType();

And then handle the exception accordingly

Hope this helps :)