WCF can make use of .NET’s ready-made support for serialization. .NET automatically serializes and deserializes objects using reflection. .NET captures the value of each of the object’s fields and serializes it to memory, to a file, or to a network connection. For deserializing, .NET creates a new object of the matching type, reads its persisted field values, and sets the values of its fields using reflection. Because reflection can access private fields, .NET takes a complete snapshot of the state of an object during serialization and perfectly reconstructs that state during deserialization. .NET serializes the object state into a stream, which is a logical sequence of bytes, independent of a particular medium such as a file, memory, a communication port, or any other resource.

[AttributeUsage(AttributeTargets.Delegate|
                AttributeTargets.Enum    |
                AttributeTargets.Struct  |
                AttributeTargets.Class,
                Inherited = false)]
public sealed class SerializableAttribute : Attribute
{}

[Serializable]
class MyClass
{...}

class MyOtherClass
{...}

[Serializable]
class MyClass
{
   [NonSerialized]
   MyOtherClass m_OtherClass;
   /* Methods and properties */
}

[Serializable]
class MyClass
{
   [NonSerialized]
   string m_Name;
}

public interface IFormatter
{
   object Deserialize(Stream serializationStream);
   void Serialize(Stream serializationStream,object graph);
   // More members
}

public sealed class BinaryFormatter : IFormatter,...
{...}
public sealed class SoapFormatter : IFormatter,...
{...}

Due to the deficiencies of the classic .NET formatters, WCF has to provide its own service-oriented formatter. The formatter, DataContractSerializer, is capable of sharing just the data contract, not the underlying type information. DataContractSerializer is defined in the System.Runtime.Serialization namespace and is partially listed in Example 3-1.

public abstract class XmlObjectSerializer
{
   public virtual object ReadObject(Stream stream);
   public virtual object ReadObject(XmlReader reader);
   public virtual void WriteObject(XmlWriter writer,object graph);
   public void WriteObject(Stream stream,object graph);
   //More members
}
public sealed class DataContractSerializer : XmlObjectSerializer
{
   public DataContractSerializer(Type type);
   //More members
}

DataContractSerializer captures only the state of the object according to the serialization or data contract schema. Note that DataContractSerializer does not support IFormatter.

WCF uses DataContractSerializer automatically under the covers, and developers should never need to interact with it directly. However, you can use DataContractSerializer to serialize types to and from a .NET stream, similar to using the legacy formatters. Unlike when using the binary or SOAP formatters, however, you need to supply the DataContractSerializer constructor with the type to operate on, because no type information will be present in the stream:

MyClass obj1 = new MyClass();
DataContractSerializer formatter = new DataContractSerializer(typeof(MyClass));

using(Stream stream = new MemoryStream())
{
   formatter.WriteObject(stream,obj1);
   stream.Position = 0;
   MyClass obj2 = (MyClass)formatter.ReadObject(stream);
}

While you can use DataContractSerializer with .NET streams, you can also use it in conjunction with XML readers and writers when the only form of input is the raw XML itself, as opposed to some medium such as a file or memory.

Note the use of the amorphous object in the definition of DataContractSerializer in Example 3-1. This means that there will be no compile-time-type safety, because the constructor can accept one type, the WriteObject() method can accept a second type, and the ReadObject() method can cast to yet a third type.

To compensate for that, you can define your own generic wrapper around DataContractSerializer, as shown in Example 3-2.

public class DataContractSerializer<T> : XmlObjectSerializer
{
   DataContractSerializer m_DataContractSerializer;

   public DataContractSerializer()
   {
      m_DataContractSerializer = new DataContractSerializer(typeof(T));
   }
   public new T ReadObject(Stream stream)
   {
      return (T)m_DataContractSerializer.ReadObject(stream);
   }
   public new T ReadObject(XmlReader reader)
   {
      return (T)m_DataContractSerializer.ReadObject(reader);
   }
   public void WriteObject(Stream stream,T graph)
   {
      m_DataContractSerializer.WriteObject(stream,graph);
   }
   public void WriteObject(XmlWriter writer,T graph)
   {
      m_DataContractSerializer.WriteObject(writer,graph);
   }
   //More members
}

The generic class DataContractSerializer<T> is much safer to use than the object-based DataContractSerializer:

MyClass obj1 = new MyClass();
DataContractSerializer<MyClass> formatter = new DataContractSerializer<MyClass>();

using(Stream stream = new MemoryStream())
{
   formatter.WriteObject(stream,obj1);
   stream.Position = 0;
   MyClass obj2 = formatter.ReadObject(stream);
}

WCF also offers the NetDataContractSerializer formatter, which is polymorphic with IFormatter:

public sealed class NetDataContractSerializer : IFormatter,...
{...}

As its name implies, similar to the legacy .NET formatters, the NetDataContractSerializer formatter captures the type information in addition to the state of the object. It is used just like the legacy formatters:

MyClass obj1 = new MyClass();
IFormatter formatter = new NetDataContractSerializer();

using(Stream stream = new MemoryStream())
{
   formatter.Serialize(stream,obj1);
   stream.Position = 0;
   MyClass obj2 = (MyClass)formatter.Deserialize(stream);
}

NetDataContractSerializer is designed to complement DataContractSerializer. You can serialize a type using NetDataContractSerializer and deserialize it using DataContractSerializer:

MyClass obj1 = new MyClass();
IFormatter formatter1 = new NetDataContractSerializer();

using(Stream stream = new MemoryStream())
{
   formatter1.Serialize(stream,obj1);

   stream.Position = 0;

   DataContractSerializer formatter2 = new DataContractSerializer(typeof(MyClass));
   MyClass obj2 = (MyClass)formatter2.ReadObject(stream);
}

This capability opens the way for versioning tolerance and for migrating legacy code that shares type information into a more service-oriented approach where only the data schema is maintained.

When a service operation accepts or returns any type or parameter, WCF uses DataContractSerializer to serialize and deserialize that parameter. This means you can pass any serializable type as a parameter or returned value from a contract operation, as long as the other party has the definition of the data schema or the data contract. All the .NET built-in primitive types are serializable. For example, here are the definitions of the int and string types:

[Serializable]
public struct Int32 : ...
{...}

[Serializable]
public sealed class String : ...
{...}

This is the only reason why any of the service contracts shown in the previous chapters actually worked: WCF offers implicit data contracts for the primitive types because there is an industry standard for the schemas of those types.

To use a custom type as an operation parameter, there are two requirements: first, the type must be serializable, and second, both the client and the service need to have a local definition of that type that results in the same data schema.

Consider the IContactManager service contract used to manage a contacts list:

[Serializable]
struct Contact
{
   public string FirstName;
   public string LastName;
}

[ServiceContract]
interface IContactManager
{
   [OperationContract]
   void AddContact(Contact contact);

   [OperationContract]
   Contact[] GetContacts();
}

If the client uses an equivalent definition of the Contact structure, it can pass a contact to the service. An equivalent definition might be anything that results in the same data schema for serialization. For example, the client might use this definition instead:

[Serializable]
struct Contact
{
   public string FirstName;
   public string LastName;
   [NonSerialized]
   public string Address;
}