XML 序列化和反序列化性能比较

Question

这个问题在不同的网站上问过，但我找不到任何有用的答案，而且我仍然遇到一些性能问题。 我的公共层应用程序中有两个序列化器方法

    public static string Serializer(object o)
    {
        var x = new XmlSerializer(o.GetType());
        var writer = new StringWriter();
        var xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings { OmitXmlDeclaration = true });
        var emptyNs = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
        x.Serialize(xmlWriter, o, emptyNs);
        return writer.ToString();
    }

    public static string Serializer<T>(T o)
    {
        var x = new XmlSerializer(typeof(T));
        var writer = new StringWriter();
        var xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings { OmitXmlDeclaration = true });
        x.Serialize(xmlWriter, o, new XmlSerializerNamespaces( new[] { XmlQualifiedName.Empty } ));
        return writer.ToString();
    } 

还有两种反序列化方法

    public static T Deserializer<T>(string objectData)
    {
        var serializer = new XmlSerializer(typeof(T));
        T result;
        using (TextReader reader = new StringReader(objectData))
        {
            result =(T) serializer.Deserialize(reader);
        }
        return result;
    }

    public static object Deserializer(object o, string filename)
    {
        object retVal;
        var ser = new XmlSerializer(o.GetType());
        using (var reader = XmlReader.Create(filename))
        {
            retVal = ser.Deserialize(reader);
        }
        return retVal;
    }

我在两种序列化程序方法中运行了不同的负载测试，所有这些都表明Serializer<T>(T o) 的工作速度比Serializer(object o) 慢，在我看来这必须是相反的，因为typeof() 更快并且类型已知不同于目的。我想先了解一下您的意见？
其次，在另一个名为

的方法中使用的序列化器和反序列化器方法

 public static TResponse  SendRequest <TRequest,TResponse>(TRequest rq, Uri requestUri) 

哪个负责将请求发送到网络服务器并获取响应，有没有办法让它更高效？

Answer 1

我编写了以下代码，但没有发现任何显着差异。不过，通过泛型进行序列化会稍微快一些。代码如下：

public class TestData {
        public string Name { get; set; }
        public string FullName { get; set; }
        public string Address { get; set; }
        public int PostalCode { get; set; }

        public TestData() {

        }
        public TestData(string name, string fullName, string address, int postalCode) {
            Name = name;
            FullName = fullName;
            Address = address;
            PostalCode = postalCode;
        }
    }

    public static class Program
    {

        public static string Serializer(object o)
        {
            var x = new XmlSerializer(o.GetType());
            var writer = new StringWriter();
            var xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings { OmitXmlDeclaration = true });
            var emptyNs = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
            x.Serialize(xmlWriter, o, emptyNs);
            return writer.ToString();
        }

        public static string Serializer<T>(T o)
        {
            var x = new XmlSerializer(typeof(T));
            var writer = new StringWriter();
            var xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings { OmitXmlDeclaration = true });
            x.Serialize(xmlWriter, o, new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty }));
            return writer.ToString();
        } 

        public static void Main(string[] args) {
            Random rand = new Random();
            const int numberOfCycles = 1000000;

            Stopwatch watch = new Stopwatch();
            watch.Start();
            for (int i = 0; i < numberOfCycles; i++) {
                object data = new TestData("", "", "", rand.Next());
                Serializer(data);
            }
            watch.Stop();

            Console.WriteLine(string.Format("Through object:{0}", watch.ElapsedMilliseconds));

            watch.Restart();
            for (int i = 0; i < numberOfCycles; i++) {
                Serializer(new TestData("", "", "", rand.Next()));
            }            
            watch.Stop();
            Console.WriteLine(string.Format("Through generic:{0}", watch.ElapsedMilliseconds));

            Console.ReadLine();
        }
    }

也许最好与我们分享一个您尝试序列化/反序列化的类，并分享您估计序列化方法执行时间的代码。