wcf 基础教程 契约 Contract 数据契约DataContract序列化前身 XmlSerializer xml序列化

本来今天打算描述一下数据契约的序列化，毕竟只是单纯的说数据契约的作用也没有太大意义，但是我发现如果单纯的叙述wcf的序列胡DataSerializer 很困难，因为它采用的事xml序列化，所以今天打乱了我的计划，来介绍一下.Net中的xml序列化，毕竟我们在使用序列化器的时候，很多时候生成的都是xml。

契约是交互双方或多方就某个问题达成的一共共识，而信息交换式wcf通信的唯一手段，也是跨平台的关键，所以契约的最根本目的不是定义什么操作方式，而是对消息的结构进行规范、统一，只有通信双方对消息的结构达成了一致，通信才可能进行。

wcf默认的数据交换方式就是xml，虽然说数据在wcf中有CLR对象和Xml两种，但是CLR对象时强类型语言才会有的，而xml才是可以和其他系统通信的手段。CLR对象要传输到远程客户端，需要序列化，默认的使用xml传输，那么就会使用到Xml序列化，今天我们一起来了解一下，.Net中如何把数据序列化成xml的，或者说其中有什么规律存在，因为打乱了我的计划，所以说这篇博客可能会显得有一点乱，没有条理，因为我是想到哪儿，写到哪儿，各位莫怪。

其中有一点，wcf虽然默认的事采用xml序列化，但是不是说不可以采用其他格式序列化，json也可以正常传输，并且可能是我们的wcf服务和手机客户端通信的首选。

在.Net中，.Net framework 就对基于XMl的序列化提供了原生的支持，比如传统的web服务就是通过XmlSerializer进行序列化和反序列化，xmlSerializer也可以应用到wcf中，因为wcf也是作为.Net framework的一个组件提供的。

我们来看一下默认的xml生成规则。这个东西说不是特别好说，还是通过一个简单的示例让我们一起来了解它，有码有真相。项目还是采用我们原来的项目，只是我们这次在控制台运行。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Diagnostics;

namespace Chinaer.WcfDemo.ConsoleClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person(25, Guid.NewGuid())
            {
                Date = DateTime.Now
            };
            Serialize<Person>(person, "person.xml");
            Console.Read();
        }

        /// <summary>
        /// 序列化方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="instace"></param>
        /// <param name="fileName"></param>
        public static void Serialize<T>(T instace, string fileName)
        {
            using (XmlWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(writer, instace);
            }
            Process.Start(fileName);
        }
    }
    /// <summary>
    /// 定义一个实体类 Person
    /// </summary>
    public class Person
    {
        //注意我们没有默认的构造函数
        private double Age { get; set; } //私有字段 年龄

        public Guid ID { get; set; } //公有的随机数

        public DateTime Date { get; set; }

        public Person(double age, Guid id)
        {
            this.Age = age;
            this.ID = id;
        }
    }






}

请注意，如果你直接运行上面的代码会出现异常信息。

为什么我没有添加默认的空的无参数的构造函数，就会出现异常呢？因为在反序列化的时候需要调用它。在反序列化的时候会调用无参数的空构造函数来生成目标对象，然后填充数值。

下面我们添加空的无参数的构造函数。

<?xml version="1.0" encoding="utf-8"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<ID>1d988f1f-3fe4-463b-84ce-7f771449280d</ID>
<Date>2013-03-21T22:19:34.7687866+08:00</Date>
</Person>

通过生成的xml文件，对应我们定义在类Person中的属性我们可以得到如下几点有用的信息：

1. xml根节点的名称为对象类型的名称，或者说是类名
2. 对象属性或字段以xmlElement xml元素的形式输出，名称和他们的名称一致
3. 只有public类型的成员才会被序列化，我们在xml文件中没有看到Age，因为它是private 标识的，其他如internal的也不会被序列化
4. xml元素出现的顺序和他们在类中存在的顺序是一致的。

下面我们再来思考一个问题，如果属性是只读的或者是只写的，那会出现什么情况呢？程序员的性格就是一切以程序运行为准，那么我们就来测试一下结果吧。请再次注意，这次我做的修改，我更改属性为只读或者只写，并且我还添加了两个属性，但是我在实例化对象的时候，并没有为它赋值，或者我们可以为UserName赋值。

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Diagnostics;

namespace Chinaer.WcfDemo.ConsoleClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person(25, Guid.NewGuid())
            {
                Date = DateTime.Now
            };

            person.UserName = "guozhiqi";
            //person.UserPwd = "123";
            Serialize<Person>(person, "person.xml");
            Console.Read();
        }

        /// <summary>
        /// 序列化方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="instace"></param>
        /// <param name="fileName"></param>
        public static void Serialize<T>(T instace, string fileName)
        {
            using (XmlWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(writer, instace);
            }
            Process.Start(fileName);
        }
    }
    /// <summary>
    /// 定义一个实体类 Person
    /// </summary>
    public class Person
    {
        private Guid _id;

        private DateTime _date;
        //注意我们没有默认的构造函数
        internal double Age { get; set; } //私有字段 年龄

        public Guid ID { get { return _id; } } //公有的随机数

        public DateTime Date { set { _date = value; } }

        public string UserName { get; set; }

        public string UserPwd { get; set; }
        public Person() { }
        public Person(double age, Guid id)
        {
            this.Age = age;

        }
    }






}

请再次注意我做的更改，添加了两个属性UserName和UserPwd，并且只为UserName赋值，而没有为UserPwd赋值，还有我更改ID为只读，date为只写属性，下面我们来看生成的xml。

<?xml version="1.0" encoding="utf-8"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <UserName>guozhiqi</UserName>
</Person>

请再次对比我们生成的xml文件和类之间的关系，由此我们再次总结几点：

1. 只读或只写的属性不会被序列化，只有可读写的属性可以序列化。当然字段不存在是否只读或只写，所以是可序列化的，它只受到public等标示符的影响。
2. 如果在实例化对象时，不会对象的属性赋值，那么它是不会序列化的。这就告诉我们，如果再传递参数的时候，如果想传递一个空，千万不要认为不为对象赋值就可以，我们必须制定一个值，它才会序列化。

既然说到了访问修饰符、只读或只写，但是我印象中只读或只写我们可以定义，举例来说，如果我们定义只读属性，那么我们设置set为private也应该可以实现只读功能。那么我们就来尝试一下这个是否可以序列化。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Diagnostics;

namespace Chinaer.WcfDemo.ConsoleClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person(25, Guid.NewGuid())
            {
                Date = DateTime.Now
            };

            person.UserName = "guozhiqi";
            //person.UserPwd = "123";
            Serialize<Person>(person, "person.xml");
            Console.Read();
        }

        /// <summary>
        /// 序列化方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="instace"></param>
        /// <param name="fileName"></param>
        public static void Serialize<T>(T instace, string fileName)
        {
            using (XmlWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(writer, instace);
            }
            Process.Start(fileName);
        }
    }
    /// <summary>
    /// 定义一个实体类 Person
    /// </summary>
    public class Person
    {
        private Guid _id;

        private DateTime _date;
        //注意我们没有默认的构造函数
        internal double Age { get; set; } //私有字段 年龄

        public Guid ID { get; private set; } //公有的随机数

        public DateTime Date { set; private get; }

        public string UserName { get; set; }

        public string UserPwd { get; set; }
        public Person() { }
        public Person(double age, Guid id)
        {
            this.Age = age;

        }
    }

}

这一次做的修改很小，只是简单的把自动属性的set设置为了private set或者get设置为了private get；这也是实现了只读或只写功能。那么我们运行程序是否可以得到我们想要的结果呢？

不可思议的一幕出现了，只写属性get不写不会被序列化，但是如果加上private get 就会出现异常？这是什么原因呢？我们尝试解决办法，毕竟这个异常信息提供的错误信息太少。

打开异常详细信息，我们看到了一个有用的信息，未将对象引用到对象的示例，可以说这是我调试程序过程中见得最多，但是最难解决的难题。

既然有了目标，那肯定是更改的属性出了问题，我们使用的是自动属性，如果我们更改为普通的字段是否可以呢？试试吧

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Diagnostics;

namespace Chinaer.WcfDemo.ConsoleClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person(25, Guid.NewGuid())
            {
                Date = DateTime.Now
            };

            person.UserName = "guozhiqi";
            //person.UserPwd = "123";
            Serialize<Person>(person, "person.xml");
            Console.Read();
        }

        /// <summary>
        /// 序列化方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="instace"></param>
        /// <param name="fileName"></param>
        public static void Serialize<T>(T instace, string fileName)
        {
            using (XmlWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(writer, instace);
            }
            Process.Start(fileName);
        }
    }
    /// <summary>
    /// 定义一个实体类 Person
    /// </summary>
    public class Person
    {
        private Guid _id;

        private DateTime _date;
        //注意我们没有默认的构造函数
        internal double Age { get; set; } //私有字段 年龄

        public Guid ID
        {
            get { return _id; }
            private set
            {
                _id = value;
            }
        } //公有的随机数

        public DateTime Date
        {
            private set
            {
                _date = value;
            }
            get
            {
                return _date;
            }
        }

        public string UserName { get; set; }

        public string UserPwd { get; set; }
        public Person() { }
        public Person(double age, Guid id)
        {
            this.Age = age;

        }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Diagnostics;

namespace Chinaer.WcfDemo.ConsoleClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person(25, Guid.NewGuid())
            {
                Date = DateTime.Now
            };

            person.UserName = "guozhiqi";
            //person.UserPwd = "123";
            Serialize<Person>(person, "person.xml");
            Console.Read();
        }

        /// <summary>
        /// 序列化方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="instace"></param>
        /// <param name="fileName"></param>
        public static void Serialize<T>(T instace, string fileName)
        {
            using (XmlWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(writer, instace);
            }
            Process.Start(fileName);
        }
    }
    /// <summary>
    /// 定义一个实体类 Person
    /// </summary>
    public class Person
    {
        private Guid _id;

        private DateTime _date;
        //注意我们没有默认的构造函数
        internal double Age { get; set; } //私有字段 年龄

        public Guid ID
        {
            get { return _id; }
            private set
            {
                _id = value;
            }
        } //公有的随机数

        public DateTime Date
        {
            private set
            {
                _date = value;
            }
            get
            {
                return _date;
            }
        }

        public string UserName { get; set; }

        public string UserPwd { get; set; }
        public Person() { }
        public Person(double age, Guid id)
        {
            this.Age = age;

        }
    }

}

请注意我这次的修改，只是添加了私有字段，让属性使用，但是我没有更改任何地方，但是运行起来的结果仍然让我很无奈，直呼程序员 真是伤不起啊。

遇到了和刚才一样的异常信息，无奈啊，现在我只是看到那个应用在属性上的private最可疑，我们试着去掉它，那么就和我们上面做的只读或只写的一样的，肯定是正确的，我也测试了，确实正确，不再赘述了。

好了，这次就写这么多，我再写下一篇，控制xml的序列化，因为博客园每隔三个小时才可以发布到博客园首页，所以我先提供一下，记得有时间浏览一下奥。

总结一下，xml的序列化没有什么重点，这篇博客重点就是发现了.Net序列化成xml的过程中我们可能遇到的几个原则。虽然知识点不大，但是对我们以后理解wcf的序列化器也是很有帮助的。

下一篇wcf 基础教程 契约 Contract 控制xml输出 数据契约DataContract序列化前身 XmlSerializer xml序列化