using System;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

public class Program

{

    public static void Main()

    {

        CallApiMethodAndDumpResults(@"{""retCode"":0,""retMsg"":""OK"",""data"":41272}");

        CallApiMethodAndDumpResults(@"{""retCode"":1000,""retMsg"":""No admin"",""data"":{}}");

    }

    private static void CallApiMethodAndDumpResults(string json)

    {

        Console.WriteLine("Simulated JSON response from server: " + json);

        var command = new JsonCommand

        {

            ResponseToReturn = new PostResponse

            {

                Response = json

            }

        };

        Console.WriteLine("Deserializing into JsonResponse<int>...");

        JsonResponse<int> resp = SendTypedApiRequest<int>(command, "", "");

        if (resp != null)

        {

            Console.WriteLine("RetCode: " + resp.RetCode);

            Console.WriteLine("RetMsg: " + resp.RetMsg);

            Console.WriteLine("Data: " + resp.Data);

        }

        else

        {

            Console.WriteLine("response is null");

        }

        Console.WriteLine();

    }

    public static JsonResponse<T> SendTypedApiRequest<T>(JsonCommand command, string apiPath, string description, int expectedResponseCode = 0)

    {

        const int OK = 200;

        try

        {

            var r = SendPost(apiPath, command);

            if (r.Code == OK && r.Response != null)

            {

                var settings = new JsonSerializerSettings();

                settings.Converters.Add(new JsonResponseConverter());

                var jsonResponse = JsonResponse<T>.Deserialize(r.Response, settings);

                if (jsonResponse.RetCode != expectedResponseCode)

                {

                    // handle errors

                }

                return jsonResponse;

            }

        }

        catch { }

        return null;

    }

    private static PostResponse SendPost(string apiPath, JsonCommand command)

    {

        return command.ResponseToReturn;

    }

}

​

​

public class PostResponse

{

    public int Code { get { return 200; } }

    public string Response { get; set; }

}

​

public class JsonCommand

{

    public PostResponse ResponseToReturn { get; set; }

}

​

public class JsonResponse<T>

{

    public int RetCode { get; set; }

    public string RetMsg { get; set; }

    public T Data { get; set; }

    public static JsonResponse<T> Deserialize(string json, JsonSerializerSettings settings = null)

    {

        return JsonConvert.DeserializeObject<JsonResponse<T>>(json, settings);

    }

}

​

public class JsonResponseConverter : JsonConverter

{

    public override bool CanConvert(Type objectType)

    {

        return objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(JsonResponse<>);

    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

    {

        // Load JSON data into a JObject

        JObject obj = JObject.Load(reader);

        // Remove the problematic data property from the JObject

        JProperty dataProp = obj.Property("data");

        if (dataProp != null) dataProp.Remove();

        // Create a JsonResponse object and populate it with the 

        // well-behaved properties in the JObject (e.g. RetCode, RetMsg)

        object jsonResponse = Activator.CreateInstance(objectType);

        serializer.Populate(obj.CreateReader(), jsonResponse);

        try

        {

            // Now try to add the data property into the same response

            if (dataProp != null)

            {

                JObject data = new JObject(dataProp);

                serializer.Populate(data.CreateReader(), jsonResponse);

            }

        }

        catch (JsonException) { }  // if it doesn't work, eat the exception

        return jsonResponse;

    }

    public override bool CanWrite

    {

        get { return false; }

    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

    {

        throw new NotImplementedException();

    }

}

​