theburningmonk.com

I came across this blog post the other day which intro­duced to me a cool addi­tion to the Dat­a­Con­tract seri­al­izer — the abil­ity to gen­er­ate XML by ref­er­ence rather than by value:

http://www.zamd.net/2008/05/20/DataContractSerializerAndIsReferenceProperty.aspx

Not much for me to add to it really, just read the blog to see how it works.

Using entity classes in your appli­ca­tion and WCF is com­plain­ing about the cir­cu­lar ref­er­ences between your classes? Well, I had the exact same prob­lem not long ago, and I found this post on James Kovac’s blog about cir­cu­lar ref­er­ences and how to get around them:

http://www.jameskovacs.com/blog/GoingAroundInCirclesWithWCF.aspx

The key things to note from this post is that:

1. WCF can han­dle cir­cu­lar ref­er­ences, but is not switched on by default
2. There is a boolean flag in the con­struc­tor for the Dat­a­Con­tract­Se­ri­al­izer class which enables object ref­er­ences to be preserved
3. We can tell WCF to switch this on by deriv­ing from the Dat­a­Con­tract­Se­ri­al­ize­r­Op­er­a­tionBe­hav­iour class (as shown in the blog post above)

By this point you’re prob­a­bly won­der­ing why cir­cu­lar ref­er­ence han­dling is not enabled by default, accord­ing to James Kovac, it’s because WCF by default tries to respect inter­op­er­abil­ity safety:

Now why can’t WCF han­dle cir­cu­lar ref­er­ences out-of-the-box. The rea­son is that there is no industry-accepted, inter­op­er­a­ble way of express­ing any­thing but parent-child rela­tion­ships in XML. You can use the ID/IDREF fea­ture of XML or the key/keyref fea­ture of XML Schema, but a lot of seri­al­iz­ers don’t respect these attrib­utes or han­dle them prop­erly. So if you want to seri­al­ize cir­cu­lar ref­er­ences, you need to stray out of the realm of safe interoperability.

So here are the classes you need to cre­ate to extend Dat­a­Con­tract­Se­ri­al­ize­r­Op­er­a­tionBe­hav­iour in order to pre­serve object reference:

public class PreserveReferencesOperationBehavior : DataContractSerializerOperationBehavior
{
     public PreserveReferencesOperationBehavior(OperationDescription operation) : base(operation)
     {
     }

     public PreserveReferencesOperationBehavior(
          OperationDescription operation, DataContractFormatAttribute dataContractFormatAttribute)
          : base(operation, dataContractFormatAttribute)
     {
     }

     public override XmlObjectSerializer CreateSerializer(
          Type type, XmlDictionaryString name, XmlDictionaryString ns, IList<Type> knownTypes)
     {
          return new DataContractSerializer(type, name, ns, knownTypes,
                                            0x7FFF /*maxItemsInObjectGraph*/,
                                            false/*ignoreExtensionDataObject*/,
                                            true/*preserveObjectReferences*/,
                                            null/*dataContractSurrogate*/);
     }
}

And the attribute to use on your oper­a­tion contract:

public class PreserveReferencesAttribute : Attribute, IOperationBehavior
{
     public void AddBindingParameters(OperationDescription description,
                                      BindingParameterCollection parameters)
     {
     }

     public void ApplyClientBehavior(OperationDescription description, ClientOperation proxy)
     {
          IOperationBehavior innerBehavior = new PreserveReferencesOperationBehavior(description);
          innerBehavior.ApplyClientBehavior(description, proxy);
     }

     public void ApplyDispatchBehavior(OperationDescription description,
                                       DispatchOperation dispatch)
     {
          IOperationBehavior innerBehavior = new PreserveReferencesOperationBehavior(description);
          innerBehavior.ApplyDispatchBehavior(description, dispatch);
     }

     public void Validate(OperationDescription description)
     {
     }
}

which you apply like this:

[OperationContract]
[PreserveReferences]
MyClass RetrieveMyClass();