欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

C#序列化字符串,对象,xml,json,集合数组,字典

程序员文章站 2022-06-16 16:53:36
...

1.对象和xml的序列化和反序列化:

先随便建一个实体类

 public class Person
    {
        public Person()
        {
        }

        public Person(string name, int age)
        {
            Name = name;
            Age = age;
        }

        public string Name { get; set; }

        public int Age { get; set; }

        public DateTime LastLoginTime { get; set; }

        public List<Course> Courses = new List<Course>();
    }
 public class Course
    {
        public Course()
        {
        }

        public Course(string name, string description)
        {
            Name = name;
            Description = description;
        }

        public string Name
        {
            get;
            set;
        }

        public string Description
        {
            get;
            set;
        }
    }

  对象和xml序列化和反序列化方法

        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="filePath"></param>
        public static void Serialiaze(String filePath)
        {
            Person c = new Person("James Chen",35);
            c.Courses.Add(new Course("高等数学", "思维工具"));
            c.Courses.Add(new Course("大学英语", "交流工具"));
            c.Courses.Add(new Course("离散数学", "计算机理论"));
            XmlSerializer xs = new XmlSerializer(typeof(Person));
            Stream stream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
            xs.Serialize(stream, c);
            stream.Close();
        }

        /// <summary>
        /// 反序列化
        /// </summary>
        /// <param name="filePath"></param>
        public static void Deserialize(String filePath)
        {
            XmlSerializer xs = new XmlSerializer(typeof(Person));
            Stream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            Person p = (Person)xs.Deserialize(stream);
            stream.Close();
        }

 调用方法

string path = Server.MapPath("upload/test.xml");
Serializer.Serialiaze(path);
Serializer.Deserialize(path);

 

2.字符串和对象的序列化和反序列化

/// <summary>
        /// 序列化 对象到字符串
        /// </summary>
        /// <param name="obj">泛型对象</param>
        /// <returns>序列化后的字符串</returns>
        public static string Serialize<T>(T obj)
        {
            try
            {
                IFormatter formatter = new BinaryFormatter();
                MemoryStream stream = new MemoryStream();
                formatter.Serialize(stream, obj);
                stream.Position = 0;
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                stream.Flush();
                stream.Close();
                return Convert.ToBase64String(buffer);
            }
            catch (Exception ex)
            {
                throw new Exception("序列化失败,原因:" + ex.Message);
            }
        }

        /// <summary>
        /// 反序列化 字符串到对象
        /// </summary>
        /// <param name="obj">泛型对象</param>
        /// <param name="str">要转换为对象的字符串</param>
        /// <returns>反序列化出来的对象</returns>
        public static T Desrialize<T>(T obj, string str)
        {
            try
            {
                obj = default(T);
                IFormatter formatter = new BinaryFormatter();
                byte[] buffer = Convert.FromBase64String(str);
                MemoryStream stream = new MemoryStream(buffer);
                obj = (T)formatter.Deserialize(stream);
                stream.Flush();
                stream.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("反序列化失败,原因:" + ex.Message);
            }
            return obj;
        }

 调用方法

//序列化
            DataTable dt = new DataTable();
            dt.Columns.Add("ID");
            dt.Columns.Add("Name");
            dt.Rows.Add(new object[] { 1, "first" });
            dt.Rows.Add(new object[] { 2, "second" });
            string result = SerializeUtilities.Serialize(dt);
            Response.Write(result);

            //反序列化
            string mystr = result;
            DataTable _resDT = new DataTable();

            _resDT = (DataTable)SerializeUtilities.Desrialize(_resDT, mystr);

            Response.Write("<br>反序列化结果<br>" + _resDT.Rows[0][0].ToString() + ":" + _resDT.Rows[0][1].ToString() + "<br>");
            Response.Write(_resDT.Rows[1][0].ToString() + ":" + _resDT.Rows[1][1].ToString() + "<br>");

 

3.JSON序列化和反序列化的处理

 /// <summary>
        /// JSON序列化
        /// </summary>
        public static string JsonSerializer<T>(T t)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            MemoryStream ms = new MemoryStream();
            ser.WriteObject(ms, t);
            string jsonString = Encoding.UTF8.GetString(ms.ToArray());
            ms.Close();
            return jsonString;
        }

        /// <summary>
        /// JSON反序列化
        /// </summary>
        public static T JsonDeserialize<T>(string jsonString)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
            T obj = (T)ser.ReadObject(ms);
            return obj;
        }


        /// <summary>
        /// JSON序列化
        /// </summary>
        public static string JsonSerializerM<T>(T t)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            MemoryStream ms = new MemoryStream();
            ser.WriteObject(ms, t);
            string jsonString = Encoding.UTF8.GetString(ms.ToArray());
            ms.Close();
            //替换Json的Date字符串
            string p = @"\\/Date\((\d+)\+\d+\)\\/";
            MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertJsonDateToDateString);
            Regex reg = new Regex(p);
            jsonString = reg.Replace(jsonString, matchEvaluator);
            return jsonString;
        }

        /// <summary>
        /// JSON反序列化
        /// </summary>
        public static T JsonDeserializeM<T>(string jsonString)
        {
            //将"yyyy-MM-dd HH:mm:ss"格式的字符串转为"\/Date(1294499956278+0800)\/"格式
            string p = @"\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}";
            MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertDateStringToJsonDate);
            Regex reg = new Regex(p);
            jsonString = reg.Replace(jsonString, matchEvaluator);
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
            T obj = (T)ser.ReadObject(ms);
            return obj;
        }

        /// <summary>
        /// 将Json序列化的时间由/Date(1294499956278+0800)转为字符串
        /// </summary>
        private static string ConvertJsonDateToDateString(Match m)
        {
            string result = string.Empty;
            DateTime dt = new DateTime(1970, 1, 1);
            return result;
        }

        /// <summary>
        /// 将时间字符串转为Json时间
        /// </summary>
        private static string ConvertDateStringToJsonDate(Match m)
        {
            string result = string.Empty;
            DateTime dt = DateTime.Parse(m.Groups[0].Value);
            dt = dt.ToUniversalTime();
            TimeSpan ts = dt - DateTime.Parse("1970-01-01");
            result = string.Format("\\/Date({0}+0800)\\/", ts.TotalMilliseconds);
            return result;
        }

 调用代码

Person p = new Person();
            p.Name = "张三";
            p.LastLoginTime = DateTime.Now;

            p.Age = 28;
            string jsonString = JsonSerializeHelper.JsonSerializer<Person>(p);
            Response.Write(jsonString);
            Person pe = JsonSerializeHelper.JsonDeserialize<Person>(jsonString);

            ///JSON序列化和反序列化日期时间的处理
            Person p2 = new Person();
            p2.Name = "张三";
            p2.Age = 28;
            p2.LastLoginTime = DateTime.Now;

            string jsonString2 = JsonSerializeHelper.JsonSerializerM<Person>(p);
            Person pe2 = JsonSerializeHelper.JsonDeserializeM<Person>(jsonString);
 ///JSON序列化和反序列化集合、字典、数组的处理
            List<Person> list = new List<Person>()
            {
                new Person(){ Name="张三", Age=28,LastLoginTime = DateTime.Now},
                new Person(){ Name="李四", Age=25,LastLoginTime = DateTime.Now}
            };

            string jsonString3 = JsonSerializeHelper.JsonSerializer<List<Person>>(list);

            Dictionary<string, string> dic = new Dictionary<string, string>();
            dic.Add("Name", "张三");
            dic.Add("Age", "28");

            string jsonString4 = JsonSerializeHelper.JsonSerializer<Dictionary<string, string>>(dic);