C# 各种序列化性能比较

来源：互联网发布：大数据txt下载编辑：程序博客网时间：2024/04/28 22:40

今天简单做了一个各种序列化的用时比较，最终结果如下：

xml:262
JSON:36
自己写的序列化:17
XML(XmlSerializerr，无需标记[Serializable])＝18
二进制(BinaryFormatter)＝45

具体代码如下：

protected void Button2_Click(object sender, EventArgs e)
 {
 List<TestData> tdlist = new List<TestData>();
 for (int i = 0; i < 10000; i++)
 {
 tdlist.Add(new TestData() { Name = Guid.NewGuid().ToString(), Address = "Address" + i.ToString() });
 }

            string msg = "";
            #region 序列化为XML
            Stopwatch watch = new Stopwatch();
            watch.Start();
            string xmlresult = XmlSerialize(tdlist);
            watch.Stop();

msg += "xml:" + watch.ElapsedMilliseconds.ToString() + " ";
#endregion

#region 序列化为JSON
 watch.Restart();
 string json = JsonSerialize(tdlist);
 watch.Stop();
 msg += "JSON:" + watch.ElapsedMilliseconds.ToString() + " ";
 #endregion

#region 自己拼写为JSON
 watch.Restart();
 StringBuilder sbjson = new StringBuilder("[");
 int j = 0;
 foreach (TestData item in tdlist)
 {
 string str = "";
 if (j < tdlist.Count - 1)
 {
 str = "{\"Name\":\"" + item.Name + "\",\"Address\":\"" + item.Address + "\"},";
 sbjson.Append(str);
 }
 else
 {
 str = "{\"Name\":\"" + item.Name + "\",\"Address\":\"" + item.Address + "\"}";
 sbjson.Append(str);
 }
 }
 sbjson.Append("]");
 string strsbjson = sbjson.ToString();
 watch.Stop();
 msg += "自己写的序列化:" + watch.ElapsedMilliseconds.ToString() + " ";
 #endregion

#region 另外一种XML
watch.Restart();

            XmlSerializer xs = new XmlSerializer(tdlist.GetType());
            using (MemoryStream stream = new MemoryStream())
            {
                xs.Serialize(stream, tdlist);
                stream.Close();
            }

watch.Stop();

msg += string.Format("XML(XmlSerializerr，无需标记[Serializable])＝{0} ", watch.ElapsedMilliseconds);
#endregion

            #region 序列化为二进制
            watch.Restart();
            try
            {
                byte[] by;
                using (MemoryStream fileStream = new MemoryStream())
                {
                    BinaryFormatter b = new BinaryFormatter();
                    b.Serialize(fileStream, tdlist);
                    by = fileStream.ToArray();
                    fileStream.Close();
                }

msg += string.Format("二进制(BinaryFormatter)＝{0} ", watch.ElapsedMilliseconds);
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }

watch.Stop();
#endregion

#region 使用SOAP
 watch.Restart();
 //使用SOAP序列化
 try
 {
 //序列化，Soap不能序列化泛型对象，所以只能指定序列化一个Programmer对象
 //using (FileStream fs = new FileStream(strFile, FileMode.Create))
 using (MemoryStream fs = new MemoryStream())
 {
 SoapFormatter formatter = new SoapFormatter();
 formatter.Serialize(fs, tdlist);
 }
 msg += string.Format("SOAP(SoapFormatter)＝{0} ", watch.ElapsedMilliseconds);
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message);
 }

watch.Stop();
#endregion

lblSerier.Text = msg;
}

        private static string XmlSerialize(object o)
        {
            XmlSerializer ser = new XmlSerializer(o.GetType());
            System.IO.MemoryStream mem = new MemoryStream();
            XmlTextWriter writer = new XmlTextWriter(mem, Encoding.UTF8);
            XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
            ns.Add("", "");
            ser.Serialize(writer, o, ns);
            writer.Close();
            return Encoding.UTF8.GetString(mem.ToArray());
        }

private static T XmlDeserialize<T>(string s)
 {
 XmlDocument xdoc = new XmlDocument();
 try
 {
 xdoc.LoadXml(s);
 XmlNodeReader reader = new XmlNodeReader(xdoc.DocumentElement);
 XmlSerializer ser = new XmlSerializer(typeof(T));
 object obj = ser.Deserialize(reader);
 return (T)obj;
 }
 catch
 {
 return default(T);
 }
 }

        private static string JsonSerialize(object o)
        {
            using (var ms = new MemoryStream())
            {
                new DataContractJsonSerializer(o.GetType()).WriteObject(ms, o);
                return Encoding.UTF8.GetString(ms.ToArray());
            }
        }

private static T JsonDeserialize<T>(string s)
 {
 using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(s)))
 {
 return (T)new DataContractJsonSerializer(typeof(T)).ReadObject(ms);
 }
 }

/// <summary>
 /// 将对象根据格式（XML/JSON）序列化成字符串结果
 /// </summary>
 /// <param name="o">目标对象</param>
 /// <param name="format">输出格式</param>
 /// <returns></returns>
 public static string Serialize(object o, Format format)
 {
 if (format == Format.Xml)
 {
 return XmlSerialize(o);
 }
 else
 {
 return JsonSerialize(o);
 }
 }

/// <summary>
 /// 将字符串根据格式（XML/JSON）反序列化成指定类型的对象
 /// </summary>
 /// <typeparam name="T">指定类型</typeparam>
 /// <param name="s">目标字符串</param>
 /// <param name="format">输入格式</param>
 /// <returns></returns>
 public static T Deserialize<T>(string s, Format format)
 {
 if (format == Format.Xml)
 {
 return XmlDeserialize<T>(s);
 }
 else
 {
 return JsonDeserialize<T>(s);
 }
 }

        public enum Format
        {
            Xml
        }

    [Serializable]
    public class TestData
    {
        internal string _Name = string.Empty;

        public string Name
        {
            get
            {
                return this._Name;
            }
            set
            {
                {
                    _Name = value;
                }
            }
        }

internal string _Address = string.Empty;

        public string Address
        {
            get
            {
                return this._Address;
            }
            set
            {
                {
                    _Address = value;
                }
            }
        }
    }