.net动态类型在处理json数据方面的应用

我们在.net中处理json数据时，经常需要定义相应的类。比如json数据：{ "name" : "hello", "age" : 18 }，则需要定义相应的类，包含属性 name、age。

如果不想定义那些烦人的类怎么办？这就用到了.net 4.0的动态类型。

1、自定义JavaScriptConverter

/// <summary>
    /// json转dynamic的转换器
    /// </summary>
    public class JsonDynamicConverter : System.Web.Script.Serialization.JavaScriptConverter
    {
        /// <summary>
        /// 自动定义反序列化
        /// </summary>
        /// <param name="dictionary"></param>
        /// <param name="type"></param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        public override object Deserialize(IDictionary<string, object> dictionary, Type type, System.Web.Script.Serialization.JavaScriptSerializer serializer)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");

            if (type == typeof(object))
            {
                return new JsonDynamicObject(dictionary);
            }

            return null;
        }

        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        public override IDictionary<string, object> Serialize(object obj, System.Web.Script.Serialization.JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 支持的类型
        /// </summary>
        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new Type[] { typeof(object) })); }
        }
    }

2、定义JsonDynamicObject

/// <summary>
    /// 代表json的动态对象
    /// </summary>
    public class JsonDynamicObject : System.Dynamic.DynamicObject
    {
        private IDictionary<string, object> dictionary { get; set; }

        /// <summary>
        /// 构造动态json对象
        /// </summary>
        /// <param name="dictionary"></param>
        public JsonDynamicObject(IDictionary<string, object> dictionary)
        {
            this.dictionary = dictionary;
        }

        /// <summary>
        /// 获取成员
        /// </summary>
        /// <param name="binder"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (this.dictionary.ContainsKey(binder.Name) == false)
            {
                result = null;
                return true;
            }

            result = this.dictionary[binder.Name];

            if (result is IDictionary<string, object>)
            {
                result = new JsonDynamicObject(result as IDictionary<string, object>);
            }
            else if (result is ArrayList && (result as ArrayList).Count > 0 && (result as ArrayList)[0] is IDictionary<string, object>)
            {
                result = new List<dynamic>((result as ArrayList).ToArray().Select(x => new JsonDynamicObject(x as IDictionary<string, object>)));
            }
            else if (result is ArrayList)
            {
                result = new List<dynamic>((result as ArrayList).ToArray());
            }

            this.dictionary[binder.Name] = result;

            return this.dictionary.ContainsKey(binder.Name);
        }

        /// <summary>
        /// 转换json字符串到dynamic
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public static dynamic FromJson(string json)
        {
            var jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
            jsSerializer.RegisterConverters(new[] { new JsonDynamicConverter() });
            return jsSerializer.Deserialize(json, typeof(object));
        }
    }

3、具体用法

var json = "{ \"name\" : \"hello\", \"age\" : 18 }";
var person = JsonDynamicObject.FromJson(json);
Console.WriteLine("name:{0},age:{1}", person.name, person.age);

是不是再也不用定义那些烦人的类了~