This documentation is archived and is not being maintained.

IDataContractSurrogate Interface

Provides the methods needed to substitute one type for another by the DataContractSerializer during serialization, deserialization, and export and import of XML schema documents (XSD).

Namespace:  System.Runtime.Serialization
Assembly:  System.Runtime.Serialization (in System.Runtime.Serialization.dll)

public interface IDataContractSurrogate

Use the IDataContractSurrogate when using the DataContractSerializer if you need to do one of the following: substitute one type or object for another, or to dynamically generate schema variations. For a sample application, see DataContract Surrogate Sample. For more information about data contracts, see Using Data Contracts.

At run time, you can find the specific DataContractSerializer for any operation in a service by using the OperationDescription to find the DataContractSerializerOperationBehavior instance. For more information about implementing the interface to create a surrogate, see Data Contract Surrogates.

You can also use the IDataContractSurrogate to affect the import and export of XML schemas when you are using the XsdDataContractExporter and XsdDataContractImporter classes. You can do so by assigning the IDataContractSurrogate to the DataContractSurrogate property of the ExportOptions class, or to the DataContractSurrogate property of the ImportOptions class. For more information, see Schema Import and Export.

The following example shows an implementation of the IDataContractSurrogate interface. The code substitutes the serialization of the Person type for a PersonSurrogated class.

class Program
{
    static void Main(string[] args)
    {
        // Create and populate an Employee instance.
        Employee emp = new Employee();
        emp.date_hired = new DateTime(1999, 10, 14);
        emp.salary = 33000;

        // Note that the Person class is a legacy XmlSerializable class 
        // without a DataContract.
        emp.person = new Person();
        emp.person.first_name = "Mike";
        emp.person.last_name = "Ray";
        emp.person.age = 44;

        // Create a serializer.
        DataContractSerializer ser =
            new DataContractSerializer(typeof(Employee));

        // Attempt to serialize without a surrogate. (This will fail.)
        Console.WriteLine(" Attempting to serialize without a surrogate: \n");
        string fileName = "surrogateEmployee.xml";
        FileStream fs = new FileStream(fileName, FileMode.Create);
        XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
        try
        {
            ser.WriteObject(writer, emp);
            writer.Flush();
            writer.Close();
        }
        catch (InvalidDataContractException)
        {
            writer.Flush();
            Console.Write(writer.ToString());
            Console.WriteLine("\n\n Cannot serialize without a surrogate since Person has no DataContract \n");
        }
        // Close the writer objects after failing to serialize.
        writer.Close();
        fs.Close();

        Console.WriteLine
            (" Now use a surrogate for the Person class and try again");
        // Create a new instance of the serializer. The  
        // constructor demands a knownTypes and surrogate.  
        // Create a Generic List for the knownTypes. Then create an 
        // instance of the surrogate class (defined below).
        List<Type> knownTypes = new List<Type>();
        LegacyPersonTypeSurrogate sur =
            new LegacyPersonTypeSurrogate();
        DataContractSerializer surrogateSerializer =
            new DataContractSerializer(typeof(Employee), knownTypes,
            int.MaxValue /*maxItemsInObjectGraph */, false /*ignoreExtensionDataObject*/
            , true /*preserveObjectReferences*/, sur);

        // Create a new writer. Then serialize with the  
        // surrogate serializer.
        FileStream newFs = new FileStream(fileName, FileMode.Create);
        XmlDictionaryWriter newWriter = XmlDictionaryWriter.CreateTextWriter(newFs);
        try
        {
            surrogateSerializer.WriteObject(newWriter, emp);
            Console.Write(newWriter.ToString());
            Console.WriteLine("Serialization succeeded. Now doing deserialization.");
            newWriter.Close();
            newFs.Close();
        }
        catch (InvalidDataContractException)
        {
            Console.WriteLine(" We never get here");
        }

        // Create a new reader object.
        FileStream fs2 = new FileStream(fileName, FileMode.Open);
        XmlDictionaryReader reader = XmlDictionaryReader.
            CreateTextReader(fs2, new XmlDictionaryReaderQuotas());

        Console.WriteLine("Trying to deserialize with surrogate.");
        try
        {
            Employee newemp = (Employee)surrogateSerializer.ReadObject(reader, false);
            reader.Close();
            fs2.Close();
            Console.WriteLine("Deserialization succeeded. \n\n");
            Console.WriteLine("Deserialized Person data: \n\t {0} {1}",
                newemp.person.first_name, newemp.person.last_name);
            Console.WriteLine("\t Age: {0} \n", newemp.person.age);
        }
        catch (SerializationException serEx)
        {
            Console.WriteLine(serEx.Message);
            Console.WriteLine(serEx.StackTrace);
        }

        Console.WriteLine("Now doing schema export/import.");
        // The following code demonstrates schema export with a surrogate. 
        // The surrogate indicates how to export the non-DataContract Person type. 
        // Without the surrogate, schema export would fail.
        XsdDataContractExporter xsdexp = new XsdDataContractExporter();
        xsdexp.Options = new ExportOptions();
        xsdexp.Options.DataContractSurrogate = new LegacyPersonTypeSurrogate();
        xsdexp.Export(typeof(Employee));

        // Write out the exported schema to a file. 
        using (FileStream fs3 = new FileStream("sample.xsd", FileMode.Create))
        {
            foreach (XmlSchema sch in xsdexp.Schemas.Schemas())
            {
                sch.Write(fs3);
            }
        }

        // The following code demonstrates schema import with  
        // a surrogate. The surrogate is used to indicate that  
        // the Person class already exists and that there is no  
        // need to generate a new class when importing the 
        // PersonSurrogated data contract. If the surrogate  
        // was not used, schema import would generate a  
        // PersonSurrogated class, and the person field  
        // of Employee would be imported as  
        // PersonSurrogated and not Person.
        XsdDataContractImporter xsdimp = new XsdDataContractImporter();
        xsdimp.Options = new ImportOptions();
        xsdimp.Options.DataContractSurrogate = new LegacyPersonTypeSurrogate();
        xsdimp.Import(xsdexp.Schemas);

        // Write out the imported schema to a C-Sharp file. 
        using (FileStream fs3 = new FileStream("sample.cs", FileMode.Create))
        {
            TextWriter tw = new StreamWriter(fs3);
            CodeDomProvider cdp = new Microsoft.CSharp.CSharpCodeProvider();
            cdp.GenerateCodeFromCompileUnit(xsdimp.CodeCompileUnit, tw, null);
            tw.Flush();
        }

        Console.WriteLine("\n To see the results of schema export and import,");
        Console.WriteLine(" see SAMPLE.XSD and SAMPLE.CS.\n");

        Console.WriteLine(" Press ENTER to terminate the sample.\n");
        Console.ReadLine();
    }
}


// This is the Employee (outer) type used in the sample.
[DataContract()]
class Employee
{
    [DataMember]
    public DateTime date_hired;

    [DataMember]
    public Decimal salary;

    [DataMember]
    public Person person;
}

// This is the Person (inner) type used in the sample. 
// Note that it is a legacy XmlSerializable type and not a DataContract type. 

public class Person
{
    [XmlElement("FirstName")]
    public string first_name;

    [XmlElement("LastName")]
    public string last_name;

    [XmlAttribute("Age")]
    public int age;

    public Person() { }
}

// This is the surrogated version of the Person type 
// that will be used for its serialization/deserialization.
[DataContract]
class PersonSurrogated
{
    [DataMember]
    public string xmlData;
    // xmlData will store the XML returned for a Person instance by the XmlSerializer.
}

// This is the surrogate that substitutes PersonSurrogated for Person. 
class LegacyPersonTypeSurrogate : IDataContractSurrogate
{
    public Type GetDataContractType(Type type)
    {
        // "Person" will be serialized as "PersonSurrogated" 
        // This method is called during serialization, 
        // deserialization, and schema export.  
        if (typeof(Person).IsAssignableFrom(type))
        {
            return typeof(PersonSurrogated);
        }
        return type;
    }
    public object GetObjectToSerialize(object obj, Type targetType)
    {
        // This method is called on serialization. 
        // If Person is being initialized... 
        if (obj is Person)
        {
            // ... use the XmlSerializer to perform the actual serialization.
            PersonSurrogated ps = new PersonSurrogated();
            XmlSerializer xs = new XmlSerializer(typeof(Person));
            StringWriter sw = new StringWriter();
            xs.Serialize(sw, (Person)obj);
            ps.xmlData = sw.ToString();
            return ps;
        }
        return obj;
    }
    public object GetDeserializedObject(object obj, Type targetType)
    {
        // This method is called on deserialization. 
        // If PersonSurrogated is being deserialized... 
        if (obj is PersonSurrogated)
        {
            //... use the XmlSerializer to do the actual deserialization.
            PersonSurrogated ps = (PersonSurrogated)obj;
            XmlSerializer xs = new XmlSerializer(typeof(Person));
            return (Person)xs.Deserialize(new StringReader(ps.xmlData));
        }
        return obj;
    }
    public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData)
    {
        // This method is called on schema import. 

        // If a PersonSurrogated data contract is in the specified namespace, 
        // do not create a new type for it because there is already an existing type, "Person".
        if (typeNamespace.Equals("http://schemas.datacontract.org/2004/07/DCSurrogateSample"))
        {
            if (typeName.Equals("PersonSurrogated"))
            {
                return typeof(Person);
            }
        }
        return null;
    }

    public System.CodeDom.CodeTypeDeclaration ProcessImportedType(System.CodeDom.CodeTypeDeclaration typeDeclaration, System.CodeDom.CodeCompileUnit compileUnit)
    {
        // Not used in this sample. 
        // You could use this method to construct an entirely  
        // new CLR type when a certain type is imported, or modify a generated 
        // type in some way. 
        return typeDeclaration;
    }


    public object GetCustomDataToExport(Type clrType, Type dataContractType)
    {
        // Not used in this sample 
        return null;
    }

    public object GetCustomDataToExport(System.Reflection.MemberInfo memberInfo, Type dataContractType)
    {
        // Not used in this sample 
        return null;
    }

    public void GetKnownCustomDataTypes(Collection<Type> customDataTypes)
    {
        // Not used in this sample
    }
}

Windows 7, Windows Vista, Windows XP SP2, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0
Show: