json 序列化与反序列化C#类

    public static class JsonSerializer  
        {  
            private static ITracing _tracing = TracingManager.GetTracing(typeof(JsonSerializer));  
      
      
            /// <summary>  
            /// 将指定对象序列化为 JavaScript 对象表示法 (JSON) 数据，并将生成的 JSON 写入流中。  
            /// </summary>  
            /// <typeparam name="T">对象类型</typeparam>  
            /// <param name="stream">流对象</param>  
            /// <param name="obj">序列化对象</param>  
            public static void Serialize<T>(Stream stream,T obj)  
            {  
                JsonSerializeProxy<T>.Default.Serialize(stream,obj);  
            }  
      
      
            /// <summary>  
            /// 将指定对象序列化为 JavaScript 对象表示法 (JSON) 数据，并返回对应的字符串。  
            /// </summary>  
            /// <typeparam name="T">对象类型</typeparam>  
            /// <param name="obj">序列化对象</param>  
            /// <returns>JavaScript 对象表示法 (JSON) 字符串</returns>  
            public static string Serialize<T>(T obj)  
            {  
                using (MemoryStream ms = new MemoryStream())  
                {  
                    JsonSerializeProxy<T>.Default.Serialize(ms,obj);  
      
      
                    string jsonStr = Encoding.UTF8.GetString(ms.ToArray());  
      
      
                    _tracing.InfoFmt("{0} json serialize result: {1}",typeof(T).ToString(),jsonStr);  
      
      
                    return jsonStr;  
                }  
            }  
      
      
            public static T DeSerialize<T>(string jsonStr)  
            {  
                return JsonSerializeProxy<T>.Default.DeSerialize(jsonStr);  
            }  
        }  
      
      
        public class JsonSerializeProxy<T>  
        {  
            private static readonly JsonSerializeProxy<T> _default = new JsonSerializeProxy<T>();  
            private DataContractJsonSerializer _serializer;  
      
      
            public static JsonSerializeProxy<T> Default  
            {  
                get  
                {  
                    return _default;  
                }  
            }  
      
      
            private JsonSerializeProxy()  
            {  
                _serializer = new DataContractJsonSerializer(typeof(T));  
            }  
      
      
            public void Serialize(Stream stream,T obj)  
            {  
                _serializer.WriteObject(stream,obj);  
            }  
      
      
            /// <summary>  
            /// 将JSON字符串反序列化为对象  
            /// </summary>  
            /// <param name="jsonStr">json字符串</param>  
            /// <returns></returns>  
            public T DeSerialize(string jsonStr)  
            {  
                MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonStr));  
                T obj = (T)_serializer.ReadObject(ms);  
                return obj;  
            }  
      
      
        }