Object转化成JSON字符串

有关JSON的介绍，请参见http://www.json.org/json-zh.html
对于一个类，其中可能包括field, property，方法不做JSON序列化。我们可以去field和property进行JSON转化。
模仿反射中的FieldInfo和PropertyInfo， 两者都继承于MemberInfo，我们定义三个类，用来存储field，property的信息：

JsonMemberInfo.cs

using System;

namespace XXX.JsonSerializer
{
    public class JsonMemberInfo
    {
        protected JsonAttrribute attribute;

        public JsonAttrribute Attribute
        {
            get
            {
                return this.attribute;
            }
            set
            {
                this.attribute = value;
            }
        }
    }
}

JsonFieldInfo.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace XXX.JsonSerializer
{
    public class JsonFieldInfo : JsonMemberInfo
    {
        private FieldInfo info;

        public FieldInfo Info
        {
            get
            {
                return this.info;
            }
            set
            {
                this.info = value;
            }
        }

        public string JsonName
        {
            get
            {
                if ((this.attribute != null) && (this.attribute.JsonName != string.Empty))
                {
                    return this.attribute.JsonName;
                }
                else
                {
                    return this.info.Name;
                }
            }
        }

        public JsonFieldInfo(FieldInfo i)
        {
            this.info = i;
        }
    }
}

 

JsonPropertyInfo.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace XXX.JsonSerializer
{
    public class JsonPropertyInfo : JsonMemberInfo
    {
        private PropertyInfo info;

        public PropertyInfo Info
        {
            get
            {
                return this.info;
            }
            set
            {
                this.info = value;
            }
        }

        public string JsonName
        {
            get
            {
                if ((this.attribute != null) && (this.attribute.JsonName != string.Empty))
                {
                    return this.attribute.JsonName;
                }
                else
                {
                    return this.info.Name;
                }
            }
        }

        public JsonPropertyInfo(PropertyInfo i)
        {
            this.info = i;
        }
    }
}

接下来，我们用一个类来保存被JSON的对象的内容：

JsonClassInfo.cs

using System;

namespace XXX.JsonSerializer
{
    public class JsonClassInfo
    {
        private Type classType;
        private JsonFieldInfo[] fields;
        private JsonPropertyInfo[] properties;

        public JsonClassInfo(Type t)
        {
            if (t == null)
            {
                 throw new Exception("Json Serializer cannot get the type of the object!");
            }
            this.classType = t;
        }

        public string ClassName
        {
            get
            {
                return this.classType.Name;
            }
        }

        public Type ClassType
        {
            get
            {
                return this.classType;
            }
        }

        public JsonFieldInfo[] ClassFields
        {
            get
            {
                return this.fields;
            }
            set
            {
                this.fields = value;
            }
        }

        public JsonPropertyInfo[] ClassProperties
        {
            get
            {
                return this.properties;
            }
            set
            {
               this.properties = value;
            }
        }
    }
}

 

所有被JSON的对象的field, property的信息会保存在这个类中。
还要指定一个对象中哪些field需要被JSON，以及提供JSON序列化时的控制。我们用到Attribute这个东东：

JsonAttrribute.cs

using System;

namespace XXX.JsonSerializer
{
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    public class JsonAttrribute : Attribute
    {
        private string name;
        private bool isIgnore;

        public JsonAttrribute(bool ignore)
            : this(ignore, string.Empty)
        {

        }

        public JsonAttrribute(string name)
            : this(false, name)
        {

        }

        public JsonAttrribute() : base() { }

        public JsonAttrribute(bool ignore, string name)
        {
            this.isIgnore = ignore;
            this.name = name;
        }

        public string JsonName
        {
            get
            { 
                return this.name; 
            }
            set
            {
                this.name = value;
            }
        }

        public bool IsIgnore
        {
               get { return this.isIgnore; }
        }
    }
}

下面上重头戏，JSON序列化的实现：

JsonSerializer.cs

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;

namespace XXX.JsonSerializer
{
    public class JsonSerializer
    {
        private const string LeftBrace = "{";
        private const string RightBrace = "}";
        private const string LeftBracket = "[";
        private const string RightBracket = "]";
        private const string Comma = ", ";

        private static readonly Type stringType = typeof(string);
        private static readonly Type dateTimeType = typeof(DateTime);
        private static readonly Type jsonAttrribute = typeof(JsonAttrribute);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public string Serialize(object obj)
        {
            if (null == obj)
            {
                return string.Empty;
            }

            Type objType = obj.GetType();

            #region Serialize an Array

            if (objType.IsArray)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(LeftBracket);

                IEnumerable enumer = obj as IEnumerable;
                if (enumer != null)
                {
                    bool extraComma = false;
                    IEnumerator enumrator = enumer.GetEnumerator();
                    while (enumrator.MoveNext())
                    {
                        //recursive serialize object in array
                        sb.Append(this.Serialize(enumrator.Current));
                        sb.Append(Comma);
                        extraComma = true;
                    }

                    if (extraComma)
                    {
                        sb.Remove(sb.Length - Comma.Length, Comma.Length);
                    }
                }

                sb.Append(RightBracket);

                return sb.ToString();
            }

            #endregion

            if (objType.IsEnum)
            {
                return string.Format("'{0}'", obj.ToString());
            }

            if (objType.IsValueType)
            {
                if (objType == dateTimeType)
                {
                    return string.Format("'{0}'", EscapeCharacter(obj.ToString()));
                }
                //  The input object is value type
                if (objType.IsPrimitive)
                {
                    //  The input object is int, doublt, etc.
                    return string.Format("'{0}'", EscapeCharacter(obj.ToString()));
                }
                else
                {
                    //  The input object is struct.
                    return this.SerializeClassStruct(obj, objType);
                }
            }
            else
            {
                //  The input object is not value type
                if (objType == stringType)
                {
                    //  The input object is string
                    return string.Format("'{0}'", EscapeCharacter(obj.ToString()));
                }
                else if (objType.IsClass)
                {
                    //  The input object is a customize class.
                    return this.SerializeClassStruct(obj, objType);
                }
                else
                {
                    //  Ingore delegate and interface.
                    return string.Empty;
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private string SerializeClassStruct(object obj, Type objType)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(LeftBrace);

            bool extraComma = false;
            string strValue = string.Empty;
            JsonClassInfo classInfo = this.ReflectClassInfo(objType);

            foreach (JsonFieldInfo info in classInfo.ClassFields)
            {
                strValue = GetValue(obj, info.Info, info.JsonName, ref extraComma);

                sb.Append(strValue);
            }

            foreach (JsonPropertyInfo info in classInfo.ClassProperties)
            {
                strValue = GetValue(obj, info.Info, info.JsonName, ref extraComma);

                sb.Append(strValue);
            }

            if (extraComma)
            {
                sb.Remove(sb.Length - Comma.Length, Comma.Length);
            }

            sb.Append(RightBrace);

            return sb.ToString();
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="objType"></param>
        /// <param name="obj"></param>
        /// <param name="fieldInfo"></param>
        /// <param name="jsonName"></param>
        /// <param name="extraComma"></param>
        /// <returns></returns>
        private string GetValue(object obj, FieldInfo info, string jsonName, ref  bool extraComma)
        {
            object value = null;
            StringBuilder sb = new StringBuilder();

            if (obj == null)
            {
                return string.Empty;
            }

            if (info != null)
            {
                value = info.GetValue(obj);

                //According to XmlSerializer, if an object is null, it will NOT be serializered
                if (value != null)
                {
                    if (!string.IsNullOrEmpty(jsonName))
                    {
                        sb.Append(string.Format("'{0}':", this.EscapeCharacter(jsonName)));
                    }

                    sb.Append(Serialize(value));
                    sb.Append(Comma);
                    extraComma = true;
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="objType"></param>
        /// <param name="obj"></param>
        /// <param name="fieldInfo"></param>
        /// <param name="jsonName"></param>
        /// <param name="extraComma"></param>
        /// <returns></returns>
        private string GetValue(object obj, PropertyInfo info, string jsonName, ref  bool extraComma)
        {
            object value = null;
            StringBuilder sb = new StringBuilder();

            if (info != null)
            {
                try
                {
                    value = info.GetValue(obj, null);
                }
                catch
                {
                    //  in case the property is indexer.
                    //  It will igorne the indexer
                    value = "";
                }

                //According to XmlSerializer, if an object is null, it will NOT be serializered
                if (value != null)
                {
                    if (!string.IsNullOrEmpty(jsonName))
                    {
                        sb.Append(string.Format("'{0}':", this.EscapeCharacter(jsonName)));
                    }

                    sb.Append(Serialize(value));
                    sb.Append(Comma);
                    extraComma = true;
                }
            }
            return sb.ToString();
        }

        private JsonClassInfo ReflectClassInfo(Type objType)
        {
            //
            //We could use cache to store reflected object 
            //

            FieldInfo[] fields = objType.GetFields(BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);            

            JsonClassInfo classInfo = new JsonClassInfo(objType);

            classInfo.ClassFields = new JsonFieldInfo[fields.Length];
            for (int i = 0; i < fields.Length; ++i)
            {
                classInfo.ClassFields[i] = new JsonFieldInfo(fields[i]);

                object[] jsonInfo = fields[i].GetCustomAttributes(jsonAttrribute, true);
                if (jsonInfo != null && jsonInfo.Length > 0)
                {
                    JsonAttrribute jAttri = jsonInfo[0] as JsonAttrribute;
                    if (jAttri.IsIgnore)
                    {
                        continue;
                    }

                    classInfo.ClassFields[i].Attribute = jAttri;
                }
            }

            PropertyInfo[] properties = objType.GetProperties(BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);

            classInfo.ClassProperties = new JsonPropertyInfo[properties.Length];
            for (int i = 0; i < properties.Length; ++i)
            {
                classInfo.ClassProperties[i] = new JsonPropertyInfo(properties[i]);

                object[] jsonInfo = properties[i].GetCustomAttributes(jsonAttrribute, true);
                if (jsonInfo != null && jsonInfo.Length > 0)
                {
                    JsonAttrribute jAttri = jsonInfo[0] as JsonAttrribute;
                    if (jAttri.IsIgnore)
                    {
                        continue;
                    }

                    classInfo.ClassProperties[i].Attribute = jAttri;
                }
            }

            return classInfo;
        }

        /// <summary>
        /// Escape \ & '
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public string EscapeCharacter(string input)
        {
            return input.Replace(@"\", @"\\").Replace("'", @"\'");
        }
    }
}

通过反射，可以得到给定object里的field, property信息，然后对不同情况进行处理。
值得注意的是对象中嵌套对象需要用到递归；对数组，对象，值，在JSON序列化要区分对待；对特殊字符要转义。
使用示例：

class Program
{
    static void Main(string[] args)
    {
        TestClass tc = new TestClass();
        JsonSerializer ser = new JsonSerializer();
        string json = ser.Serialize(tc);
        Console.WriteLine(json);
    }
}

class TestClass
{
    [JsonAttrribute("NC")]
    public NestClass nc = new NestClass();

    //This field will not be serialized because ingore = true
    [JsonAttrribute(true)]
    NestClass ic = new NestClass();

    public int[] IntegerArray = new int[] {1, 2, 3 };

    //private field will not be serialized
    [JsonAttrribute("PNC")]
    private NestClass pnc = new NestClass();
}

class NestClass
{ 
    [JsonAttrribute("NF")]
    public string NestClassFiled = "NestClassFiled";

}

 

输出如下：
{'NC':{'NF':'NestClassFiled'}, 'IntegerArray':['1', '2', '3']}
新版本的.net framework中提供了把对象转成JSON的方法，在一个dll里，具体叫什么记不得了，Scottegu的blog中提到过。