有可能存在一种情况，实体类型无法进行序列化或需要在序列化的方式上进行更改，如 第三方组件供应商提供的类型或者没有源代码的组件。 对于这种情况，WCF提供IDataContractSurrogate 接口 来实现一个替身类解决此类问题。

解决问题的步骤：

1. 定义数据契约来表示序列化的类型；

2. 定义实现序列化替身的操作类，实现IDataContractSurrogate接口，并至少实现其三个方法： GetDataContractType、GetDeserializedObject、GetObjectToSerialize ，其中GetDataContractType方法会向DataContractSerializer 返回需要序列化的类型，而GetObjectToSerialize和GetDeserializedObject会实际执行序列化和反序列化。

以下代码：

假设 Employee 无法实现序列化，以EmployeeSurrogated 作为其替身类，以EmpoyyeeSurrogate实现操作，代码如下：

EmployeeSurrogated 定义：

    [DataContract]
    internal class EmployeeSurrogated
    {
        public EmployeeSurrogated(int employeeID, string firstName, string lastName)
        {
            this.employeeID = employeeID;
            this.firstName = firstName;
            this.lastName = lastName;
        }

        [DataMember]
        private int employeeID;

        [DataMember]
        private string firstName;

        [DataMember]
        private string lastName;

        public int EmployeeID
        {
            get { return this.employeeID; }
        }

        public string FirstName
        {
            get { return this.firstName; }
        }

        public string LastName
        {
            get { return this.lastName; }
        }


    }

EmployeeSurrogate 操作类：

 public class EmployeeSurrogate : IDataContractSurrogate
    {
        public object GetCustomDataToExport(Type clrType, Type dataContractType)
        {
            return null;
        }

        public object GetCustomDataToExport(System.Reflection.MemberInfo memberInfo, Type dataContractType)
        {
            return null;
        }

        /// <summary>
        /// 向DataContractSerializer 返回需要序列化的类型
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public Type GetDataContractType(Type type)
        {
            if (typeof(Employee).IsAssignableFrom(type))
            {
                return typeof(EmployeeSurrogated);
            }
            return type;
        }

        /// <summary>
        /// 执行反序列化后应返回的实际类型
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="targetType"></param>
        /// <returns></returns>
        public object GetDeserializedObject(object obj, Type targetType)
        {
            if (obj is EmployeeSurrogated)
            {
                EmployeeSurrogated oldEmployee = obj as EmployeeSurrogated;

                Employee newEmployee = new Employee() 
                {
                    EmployeeID = oldEmployee.EmployeeID, 
                    FirstName = oldEmployee.FirstName, 
                    LastName = oldEmployee.LastName 
                };
                return newEmployee;
            }
            return obj;
        }

        public void GetKnownCustomDataTypes(System.Collections.ObjectModel.Collection<Type> customDataTypes)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 将无法序列化的对象转化会替身类性
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="targetType"></param>
        /// <returns></returns>
        public object GetObjectToSerialize(object obj, Type targetType)
        {
            if (obj is Employee)
            {
                Employee oldEmployee = obj as Employee;
                EmployeeSurrogated newEmployee = new EmployeeSurrogated(oldEmployee.EmployeeID, oldEmployee.FirstName, oldEmployee.LastName);
                return newEmployee;
            }
            return obj;
        }

        public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData)
        {
            if (typeNamespace.Equals(@"http://schemas.datacontract.org/2004/07/EmplyeeSurrogated"))
            {
                if (typeName.Equals("EmployeeSurrogated"))
                {
                    return typeof(Employee);
                }
            }
            return null;
        }

        public CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit)
        {
            return typeDeclaration;
        }
    }

序列化方式：

序列化器： 注意 DataContractSerializer 的实例化调用的构造方法，此关键操作导致可以实现替代的序列化；

        public static string TryToSerialize(object obj)
        {
            DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
            using (StringWriter strWriter = new StringWriter())
            {
                using (XmlWriter xWriter = XmlWriter.Create(strWriter))
                {
                    try
                    {
                        serializer.WriteObject(xWriter, obj);
                        xWriter.Flush();
                        return strWriter.ToString();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Can not serialize without a surrogate : {0}", ex);
                    }
                }
            }
            return string.Empty;
        }

        public static string SerializeUsingSurrogate(object obj, IDataContractSurrogate surrogateObj)
        {
            DataContractSerializer serializer = new DataContractSerializer(obj.GetType(), null, int.MaxValue, false, false, surrogateObj);

            return SerializeUsingSurrogate(serializer, obj);
        }

        public static string SerializeUsingSurrogate(DataContractSerializer serializer, object obj)
        {
            using (StringWriter strWriter = new StringWriter())
            {
                using (XmlWriter xWriter = XmlWriter.Create(strWriter))
                {
                    serializer.WriteObject(xWriter, obj);
                    xWriter.Flush();
                    return strWriter.ToString();
                }
            }
        }

        public static object DeserializeUsingSurrogate(Type sourceType, IDataContractSurrogate surrogateObj, string objXml)
        {
            DataContractSerializer serializer = new DataContractSerializer(sourceType, null, int.MaxValue, false, false, surrogateObj);

            return DeserializeUsingSurrogate(serializer, objXml);
        }

        public static object DeserializeUsingSurrogate(DataContractSerializer serializer, string objXml)
        {
            using (StringReader strReader = new StringReader(objXml))
            {
                using (XmlReader xReader = XmlReader.Create(strReader))
                {
                    return serializer.ReadObject(xReader);
                }
            }
        }

最后执行：

 static void SerializeSurrogate()
        {
            Employee e = new Employee() 
            { 
                EmployeeID = 1,
                FirstName = "jerry",
                LastName = "shi"
            };

            Console.WriteLine("{0},{1},{2}", e.EmployeeID, e.FirstName, e.LastName);

            SerializeHelper.TryToSerialize(e);

            string objXml = SerializeHelper.SerializeUsingSurrogate(e, new EmployeeSurrogate());

            Console.WriteLine(objXml);

            Employee newobj = (Employee)SerializeHelper.DeserializeUsingSurrogate(e.GetType(), new EmployeeSurrogate(), objXml);

            Console.WriteLine("{0},{1},{2}", newobj.EmployeeID, newobj.FirstName, newobj.LastName);

            Console.WriteLine("Press <Enter> to continute...");
            Console.ReadLine();
        }

结果说明：