序列化与反序列化

项目中进行进程间通信,需要把数据序列化成JSON字符串进行传递,然后对接收到的JSON字符串进行反序列化成对象。

我尝试过两种方式进行处理,System.Web.Script.Serialization.JavaScriptSerializer和Newtonsoft.Json.JsonConvert。第一种可以直接引用,第二种需要添加Newtonsoft.Json.dll
第一种System.Web.Script.Serialization.JavaScriptSerializer实现代码:
JsonHelper类:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class JsonHelper
{
    private static JsonHelper _Instance;
    /// <summary>
    /// 单例访问
    /// </summary>
    public static JsonHelper Instance
    {
        get
        {
            if (_Instance == null)
            {
                lock (typeof(JsonHelper))
                {
                    if (_Instance == null)
                    {
                        _Instance = new JsonHelper();
                    }
                }
            }
            return _Instance;
        }
    }
 
 
    public string ObjToJson<T>(T t)
    {
 
        JavaScriptSerializer js = new JavaScriptSerializer();
 
        return js.Serialize(t);
 
    }
 
    public T JsonToObj<T>(string strJson)
    {
 
        JavaScriptSerializer js = new JavaScriptSerializer();
 
        return js.Deserialize<T>(strJson);
 
    }
}
使用方式:
1
2
3
4
// 将CAD_FilePath对象序列化为JSON字符串
var resStr = JsonHelper.Instance.ObjToJson<CAD_FilePath>(obj);
// 将JSON字符串反序列化为CAD_FilePath对象
var resObj = JsonHelper.Instance.JsonToObj<CAD_FilePath>(str);
 
第二种Newtonsoft.Json.JsonConvert实现代码:
JsonHelper类:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
public class JsonHelper
{
    public static string GetKeyCode(String jsonStr)
    {
        var rule = "(?<=\"keyCode\":\")([^\"]+)(?=\")";
        Regex regexKey = new Regex(rule, RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Multiline);
        var match=regexKey.Match(jsonStr);
        return match.Value;
    }
 
    /// <summary>
    /// 将对象序列化为JSON格式
    /// </summary>
    /// <param name="o">对象</param>
    /// <returns>json字符串</returns>
    public static string SerializeObject(object o)
    {
        string json = JsonConvert.SerializeObject(o);
        return json;
    }
 
    /// <summary>
    /// 解析JSON字符串生成对象实体
    /// </summary>
    /// <typeparam name="T">对象类型</typeparam>
    /// <param name="json">json字符串</param>
    /// <returns>对象实体</returns>
    public static T DeserializeJsonToObject<T>(string json) where T : class
    {
        JsonSerializer serializer = new JsonSerializer();
        StringReader sr = new StringReader(json);
        object o = serializer.Deserialize(new JsonTextReader(sr), typeof(T));
        T t = o as T;
        return t;
    }
 
    /// <summary>
    /// 解析JSON数组生成对象实体集合
    /// </summary>
    /// <typeparam name="T">对象类型</typeparam>
    /// <param name="json">json数组字符串</param>
    /// <returns>对象实体集合</returns>
    public static List<T> DeserializeJsonToList<T>(string json) where T : class
    {
        JsonSerializer serializer = new JsonSerializer();
        StringReader sr = new StringReader(json);
        object o = serializer.Deserialize(new JsonTextReader(sr), typeof(List<T>));
        List<T> list = o as List<T>;
        return list;
    }
 
 
    public static T Deserialize<T>(string strJson)
    {
        try
        {
            return JsonConvert.DeserializeObject<T>(strJson);
        }
        catch { }
 
        return default(T);
    }
 
    public static T DeserializeFromFile<T>(string filePath)
    {
        if (File.Exists(filePath))
        {
            return Deserialize<T>(File.ReadAllText(filePath, Encoding.UTF8));
        }
        return default(T);
    }
 
    public static string Serialize(Object obj)
    {
        try
        {
            return JsonConvert.SerializeObject(obj);
        }
        catch { }
 
        return String.Empty;
    }
 
    public static void SerializeToFile(Object obj, string filePath)
    {
        FileInfo fi = new FileInfo(filePath);
        if (!fi.Directory.Exists)
            fi.Directory.Create();
 
        File.WriteAllText(filePath, Serialize(obj));
    }
    /// <summary>
    /// 反序列化JSON到给定的匿名对象.
    /// </summary>
    /// <typeparam name="T">匿名对象类型</typeparam>
    /// <param name="json">json字符串</param>
    /// <param name="anonymousTypeObject">匿名对象</param>
    /// <returns>匿名对象</returns>
    public static T DeserializeAnonymousType<T>(string json, T anonymousTypeObject)
    {
        T t = JsonConvert.DeserializeAnonymousType(json, anonymousTypeObject);
        return t;
    }
}
使用方式:
1
2
3
4
// 将对象序列化为JSON字符串,不需要知道对象是哪个
var resStr = JsonHelper.SerializeObject(MsgObj)
// 将JSON字符串反序列化为LineInfo对象
var resObj = JsonHelper.DeserializeJsonToObject<LineInfo>(resultJson);
 
 
 
posted @ 2016-01-21 15:20  KarlSunstrider  阅读(217)  评论(0)    收藏  举报