一、数据契约
1.使用数据协定可以灵活控制哪些成员应该被客户端识别。
[DataContract]
public class Employee
{
[DataMember]
public string Name { get; set; }
[DataMember]
public int Age { get; set; }
[DataMember]
public string City { get; set; }
} [ServiceContract]
public interface IService
{
[OperationContract]
Employee GetAEmployee();
} public class MyService : IService
{
public Employee GetAEmployee()
{
return new Employee { Name = "小朋友", Age = };
}
}
class Program
{
static void Main(string[] args)
{
using (ServiceHost host = new ServiceHost(typeof(Service1)))
{
host.AddServiceEndpoint(typeof(IService1), new WSHttpBinding(), "http://127.0.0.1:8888/service1");
ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
behavior.HttpGetEnabled = true;
behavior.HttpGetUrl = new Uri("http://127.0.0.1:8888/service"); //httpGetUrl客户端引用的地址
host.Description.Behaviors.Add(behavior);
host.Opened += delegate
{
Console.WriteLine("服务已启动");
Console.ReadKey();
};
host.Open();
}
}
}
如果把Employee类中的某个成员的DataMember属性去掉，则在客户端代理类中就不会生成该属性
2.数据协定也有隐藏真实身份的作用
[DataContract(Name = "Worker")]
public class Employee
{
[DataMember(Name = "Worker_Name")]
public string Name { get; set; } [DataMember(Name = "Worker_Age")]
public int Age { get; set; } [DataMember(Name = "Worker_City")]
public string City { get; set; }
}
这样在客户端生成的代理类的成员名称就和服务器端不一样
3.（已知类型），在一些比较复杂的类型无法反序列化（不能识别类型）的时候，就得考虑使用KnownTypeAttribute来标注可能涉及到的外部类型，但如果遇到像泛型这些较为复杂的类型，就要考虑在带数据协定的类中添加一个静态方法，该方法返回Type 的IEnumerable，一般是Type[]就可以了，而在KnownTypeAttribute的构造函数中使用这个方法的名字。
[DataContract]
[KnownType("GetKnowTypes")]
public class Student
{
[DataMember]
public string Name;
[DataMember]
public string Phone;
[DataMember]
public AddrInfo Address;
[DataMember]
public object Scores; static Type[] GetKnowTypes()
{
return new Type[] { typeof(Dictionary<string,float>) };
}
}
[DataContract]
public class AddrInfo
{
[DataMember]
public string Province;
[DataMember]
public string City;
[DataMember]
public string DetailAddr;
}
public class MyService : IService
{
public Student GetStudentInfo()
{
Student stu = new Student();
AddrInfo info = new AddrInfo();
info.Province = "广东省";
info.City = "佛山市";
info.DetailAddr = "火星路-300号";
stu.Name = "小陈";
stu.Phone = "";
stu.Address = info;
Dictionary<string, float> m_scores = new Dictionary<string, float>();
m_scores.Add("语文", 97f);
m_scores.Add("英语", 64.5f);
m_scores.Add("数学", 38f);
m_scores.Add("历史", 77.6f);
m_scores.Add("地理", 82.3f);
stu.Scores = m_scores;
return stu;
}
}
static void Main(string[] args)
{
using (ServiceHost host = new ServiceHost(typeof(Service1)))
{
host.AddServiceEndpoint(typeof(IService1), new WSHttpBinding(), "http://127.0.0.1:8888/service1");
ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
behavior.HttpGetEnabled = true;
behavior.HttpGetUrl = new Uri("http://127.0.0.1:8888/service"); //httpGetUrl客户端引用的地址
host.Description.Behaviors.Add(behavior);
host.Opened += delegate
{
Console.WriteLine("服务已启动");
Console.ReadKey();
};
host.Open();
}
} static void Main(string[] args)
{
WS.ServiceClient cli = new WS.ServiceClient();
WS.Student stu = cli.GetStudentInfo();
string msg = "学生姓名：{0}\n联系电话：{1}\n" +
"地址信息：-----------\n" +
"省份：{2}\n" +
"市区：{3}\n" +
"详细地址：{4}";
Console.WriteLine(msg, stu.Name, stu.Phone, stu.Address.Province, stu.Address.City, stu.Address.DetailAddr);
Console.WriteLine("---------------------------------------");
Console.WriteLine("学生成绩单：");
Dictionary<string, float> scores = stu.Scores as Dictionary<string, float>;
foreach (var item in scores)
{
Console.Write("{0}：{1}\n", item.Key, item.Value);
} Console.ReadKey();
}
使用[ServiceKnownType(typeof(Order))]放在服务契约上，使用[KnownType(typeof(Order))]放在数据契约上
[ServiceContract]
[ServiceKnownType(typeof(Order))]//可以放到这里
public interface IService1
{
[OperationContract]
//[ServiceKnownType(typeof(Order))]也可以放到这里
void AddOrder(OrderBase order);
}
[DataContract]
// [KnownType(typeof(Order))]也可以放到这里
public abstract class OrderBase
{
[DataMember]
public Guid ID { get; set; } [DataMember]
public DateTime Date { get; set; } [DataMember]
public string Customer { get; set; } [DataMember]
public string ShipAddress { get; set; }
}
[DataContract]
public class Order : OrderBase
{
[DataMember]
public double TotalPrice { get; set; }
} public class Service1 : IService1
{
public void AddOrder(OrderBase order)
{
Console.WriteLine(order.Customer);
}
} public class Program
{
static void Main(string[] args)
{
using (Service1Client client = new Service1Client())
{
Order order = new Order() { Customer = "yxl" };
client.AddOrder(order); }
Console.ReadKey();
}
}
如果不标识ServiceKnownType或KnownType，客户端将不会生成Order类
二、序列化
1.NET序列化机制
在.NET Framework 3.0之前，提供了3中序列化器，序列化器理解为把可序列化的类型序列化成XML的类。这三种序列化器分别是BinaryFormatter、SoapFormatter和XmlSerializer类。下面分别介绍下这3种序列化器。
- BinaryFormatter类：把.NET Object序列化成二进制格式。在这个过程，对象的公共字段和私有字段以及类名称（包括类的程序集名），将转换成成字节流。
- SoapFormatter类：把.NET Object序列化成SOAP格式，SOAP是一种轻量、简单的，基于XML的协议。只序列化字段，包括公共字段和私有字段。
- XmlSerializer类：该类仅仅序列化公共字段和属性，且不保存类型的保真度。
对于这三种序列化机制，BinaryFormatter二进制序列化的优点是：性能高，但是不能跨平台。而SoapFormatter，XmlSerializer的优点是：跨平台、互操作性好，并且可读性强，但是传输性能不及BinaryFormatter。
原有的格式化器需要将类型的程序集及版本控制信息持久化到流中，以保证对象被反序列化为正确的类型，这种方式一定程度上妨碍面向服务交互。原因如下：BinaryFormatter和SoapFormatter具备类型保真，它们要求其所在程序集、版本等信息必须完全一致，如果不同则视为是不同类型的对象，这就要求客户端必须拥有原有的.NET 程序集。面向服务的交互方式应该更倾向于平台无关，并最大限度的解耦，因此这2个格式化器显然与WCF有些不搭。再看XmlSerializer格式化器，在功能上与DataContractSerializer格式器类似，但是为何没有使用XmlSerializer格式器而是引人新格式器，我的理解如下：在SOA服务的构建过程中，提倡契约优先的构建原则，也就是说我们应该优先构建契约后构建具体的代码，在构建过程中并不考虑其具体的序列化过程。（契约优先相对于代码优先在设计层面具有更高的抽象程度，降低了服务设计与平台的耦合度，因此我更倾向于契约优先的开发顺序。）此外，XmlSerializer为如何将数据表示成XML提供了精确的控制，DataContractSerializer则提供了较少的控制，所以DataContractSerializer的序列化过程是可预知的，容易优化，所以它与XmlSerializer相比有更好的性能（我查到的数字是提升了约10%）。
2.WCF中序列化机制
在WCF中，提供了专门用来序列化和反序列操作的类，该类就是DataContractSerializer类。一般而言，WCF会自动选择使用DataContractSerializer来对可序列话数据契约进行序列化，不需要开发者直接调用。WCF除了支持DataContractSerializer类来进行序列化外，还支持另外两种序列化器，这两种序列化器分别为：XMLSerializer（定义在System.XML.Serialization namespace）和NetDataContractSerializer (定义在System.XML.Serialization namespace)。XmlSerializer类不是WCF专用的类，Asp.net Web服务统一使用该类作为序列化器，但XmlSerializer类支持的类少于DataContractSerializer列支持的类型，但它允许对生成的XML进行更多的控制，并且支持更多的XML架构定义语言（XSD）标准。它不需要在可序列化类上有任何声明性的属性。
默认情况下，WCF 使用 DataContractSerializer 类来序列化数据类型。 此序列化程序支持下列类型：
- 基元类型（如：整数、字符串和字节数组）以及某些特殊类型（如 XmlElement 和 DateTime）。
- 数据协定类型（用 DataContractAttribute 属性标记的类型）。
- 用 SerializableAttribute 属性标记的类型，包括实现 ISerializable 接口的类型。
- 实现 IXmlSerializable 接口的类型。
- 许多常见集合类型，包括许多泛型集合类型。
DataContractSerializer类与NetDataContractSerializer类类似，它们之间主要的区别在于：在使用NetDataContractSerializer进行序列化时，不需要指定序列化的类型，如：
NetDataContractSerializer serializer =
new NetDataContractSerializer(); // 不需要明确指定序列化的类型
serializer.WriteObject(writer, p); // 而使用DataContractSerializer需要明确指定序列化的类型
DataContractSerializer serializer =
new DataContractSerializer(typeof(Order)); // 需要明确指定序列化的类型
serializer.WriteObject(writer, p);
SerializableAttribute与DataContract异同。
相同点：都是标记类型为可序列化类型
不同点：在于序列化的成员不一样，DataContract是Opt-in(明确参与)的方式，即使用DataMember特性明确标识哪些成员需要序列化，而Serializable是Opt-out方式，即使用NoSerializable特性明确标识不参与序列化的成员。
我个人意见，DataContractSerializable就用在它应该用的地方吧，如果不是用WCF，还是不要用它了，它的序列化结果有一些微软专属的东西。对于来自网络的松散Xml接口数据，XmlSerializer是不二之选。如果想把对象完整地保存下来（数据与状态），同时又不需要被人看。那就用BinaryFormatter吧，SerializableAttribute默认是使用BinaryFormatter序列化的。