Abstraction to allow System.Web.Extension JavaScriptConveters to run as JSON.Net JsonConverters.

GeometryConverter.cs

using System;
using System.Collections.Generic;
using Serialization.Text

namespace Drawing.Geometry
{
    public class GeometryConverter : IJsonConverter
    {
        public object Deserialize(IDictionary<string, object> dictionary, Type type, IJsonSerializer serializer)
        {
            Geometry geometry = null;

            if (dictionary.ContainsKey("x"))
            {
                geometry = serializer.ConvertToType<MapPoint>(dictionary);
            }
            else if (dictionary.ContainsKey("points"))
            {
                geometry = serializer.ConvertToType<Multipoint>(dictionary);
            }
            else if (dictionary.ContainsKey("paths"))
            {
                geometry = serializer.ConvertToType<Polyline>(dictionary);
            }
            else if (dictionary.ContainsKey("rings"))
            {
                geometry = serializer.ConvertToType<Polygon>(dictionary);
            }
            else if (dictionary.ContainsKey("xmin"))
            {
                geometry = serializer.ConvertToType<Envelope>(dictionary);
            }

            return geometry;
        }

        public IDictionary<string, object> Serialize(object obj, IJsonSerializer serializer)
        {
            return serializer.Deserialize<Dictionary<string, object>>(serializer.DefaultSerialize(obj));
        }

        public IEnumerable<Type> SupportedTypes
        {
            get { return new Type[] { typeof(Geometry) }; }
        }
    }
}

IJsonConverter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Serialization.Text
{
    public interface IJsonConverter
    {
        object Deserialize(IDictionary<string, object> dictionary, Type type, IJsonSerializer serializer);
        IDictionary<string, object> Serialize(object obj, IJsonSerializer serializer);
        IEnumerable<Type> SupportedTypes { get; }
    }
}

IJsonSerializer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Serialization.Text
{
    public interface IJsonSerializer
    {
        void RegisterConverters(IEnumerable<IJsonConverter> converters);
        T ConvertToType<T>(IDictionary<string, object> dictionary);
        T Deserialize<T>(string input);
        string Serialize(object obj);
        string DefaultSerialize(object obj);
    }
}

NewtonsoftJsonConverter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Newtonsoft.Json;

namespace Serialization.Text
{
    public class NewtonsoftJsonConverter : JsonConverter
    {
        private IJsonConverter _converter = null;
        private IJsonSerializer _serializer = null;

        public NewtonsoftJsonConverter(IJsonSerializer serializer, IJsonConverter converter)
        {
            _serializer = serializer;
            _converter = converter;
        }

        public override bool CanConvert(Type objectType)
        {
            foreach (Type type in _converter.SupportedTypes)
                if (type.IsAssignableFrom(objectType))
                    return true;

            return false;
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            object value = ReadValue(reader);

            if (value == null)
                return value;

            if (!(value is IDictionary<string, object>))
                throw new Exception("Expected dictionary but found a list");

            value = _converter.Deserialize((IDictionary<string, object>)value, objectType, _serializer);

            return value;
        }

        private object ReadValue(JsonReader reader)
        {
            while (reader.TokenType == JsonToken.Comment)
            {
                if (!reader.Read())
                    throw new Exception("Unexpected end.");
            }

            switch (reader.TokenType)
            {
                case JsonToken.StartObject:
                    return ReadObject(reader);
                case JsonToken.StartArray:
                    return ReadList(reader);
                default:
                    if (IsPrimitiveToken(reader.TokenType))
                        return reader.Value;

                    throw new Exception(string.Format("Unexpected token when converting to Dictionary: {0}", reader.TokenType));
            }
        }

        private bool IsPrimitiveToken(JsonToken token)
        {
            switch (token)
            {
                case JsonToken.Integer:
                case JsonToken.Float:
                case JsonToken.String:
                case JsonToken.Boolean:
                case JsonToken.Undefined:
                case JsonToken.Null:
                case JsonToken.Date:
                case JsonToken.Bytes:
                    return true;
                default:
                    return false;
            }
        }

        private object ReadList(JsonReader reader)
        {
            IList<object> list = new List<object>();

            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                    case JsonToken.Comment:
                        break;
                    default:
                        object v = ReadValue(reader);

                        list.Add(v);
                        break;
                    case JsonToken.EndArray:
                        return list;
                }
            }

            throw new Exception("Unexpected end.");
        }

        private object ReadObject(JsonReader reader)
        {
            IDictionary<string, object> dictionary = new Dictionary<string, object>();

            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                    case JsonToken.PropertyName:
                        string propertyName = reader.Value.ToString();

                        if (!reader.Read())
                            throw new Exception("Unexpected end.");

                        object v = ReadValue(reader);

                        dictionary[propertyName] = v;
                        break;
                    case JsonToken.Comment:
                        break;
                    case JsonToken.EndObject:
                        return dictionary;
                }
            }

            throw new Exception("Unexpected end.");
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            IDictionary<string, object> dictionary = _converter.Serialize(value, _serializer);
            serializer.Serialize(writer, dictionary);
        }
    }
}

NewtonsoftJsonSerializer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Newtonsoft.Json;

namespace Serialization.Text
{
    public class NewtonsoftJsonSerializer : IJsonSerializer
    {
        private JsonSerializerSettings _settings = new JsonSerializerSettings();

        public void RegisterConverters(IEnumerable<IJsonConverter> converters)
        {
            foreach (IJsonConverter converter in converters)
                _settings.Converters.Add(new NewtonsoftJsonConverter(this, converter));
        }

        public T ConvertToType<T>(IDictionary<string, object> dictionary)
        {
            string intermediate = JsonConvert.SerializeObject(dictionary);
            T value = JsonConvert.DeserializeObject<T>(intermediate);
            return value;
        }

        public T Deserialize<T>(string input)
        {
            return JsonConvert.DeserializeObject<T>(input, _settings);
        }

        public string Serialize(object obj)
        {
            return JsonConvert.SerializeObject(obj, Formatting.None, _settings);
        }

        public string DefaultSerialize(object obj)
        {
            return JsonConvert.SerializeObject(obj);
        }
    }
}