Ruurd Boeke Enterprise development and technobabble - Sneak preview: serializing objects with original values

Monday, March 17, 2008

Sneak preview: serializing objects with original values

I'll probably dedicate a bigger post to this soon, but I wanted to show you a domainmodel, some code and the xml it generates.
What you see here is two attributes that take on quite a bit of work.
EditableBusinessObject implements IEditableObject for you and also allows you to copy the currentvalues to a loadedvalues state.
CreateSerializeSurrogate generates a surrogate class that knows how to deal with loadedvalues and with circular references.
Together, they form the backbone of the client-side of your domainmodel.

Here is an example.

DomainModel:
(notice this is the full class, no other properties are here)

  0 [EditableBusinessObject]
  1 [CreateSerializeSurrogate]
  2 [Serializable]
  3 [DataContract(Namespace = "myNamespace", Name = "Person")]
  4  public class Person
  5 {
  6   [DataMember]
  7   public int IntProperty { get; set; }
  8 
  9   [DataMember]
  10   public string StringProperty { get; set; }
  11 
  12   [DataMember]
  13   public string StringProperty2 { get; set; }
  14 
  15   int neverSetInt;
  16   [DataMember]
  17   public int NeverSetInt
  18   {
  19    get
  20    {
  21     return neverSetInt;
  22    }
  23    set { neverSetInt = value; }
  24   }
  25 
  26   [DataMember]
  27   public List<string> StringLijst { get; set; }
  28 
  29   [DataMember]
  30   public List<int> IntLijst { get; set; }
  31 
  32   public Person()
  33   {
  34    StringLijst = new List<string>();
  35    IntLijst = new List<int>();
  36   }
  37 
  38 }
  39 

Some testcode:
(notice line 16 where we do a endEdit. If we had cancelled, we would've had a proper rollback)

  0    Person p = new Person();
  1    p.IntProperty = 1;
  2    p.StringProperty = "Ruurd";
  3    p.StringProperty2 = "Boeke";
  4 
  5    p.StringLijst.Add("a");
  6    p.IntLijst.Add(1);
  7 
  8    (p as IEditableBusinessObject).CopyCurrentToLoaded();
  9 
  10    (p as IEditableBusinessObject).BeginEdit();
  11 
  12    p.IntLijst.Add(2);
  13    p.StringLijst.Add("b");
  14    p.StringProperty = "Ruurd Boeke";
  15 
  16    (p as IEditableBusinessObject).EndEdit();
  17 
  18    DataContractSerializer s = new DataContractSerializer(p.GetType(), null, int.MaxValue, false, false, new SubstituteDomainDataContractSurrogate());
  19 
  20    string outMessage = GetWellFormedToContract(p, s);

And the generated xml:
(notice how the lists and 'StringProperty' are changed, and see the original value).

<PersonSurrogate xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="myNamespace">

    <IntLijst xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">

        <d2p1:int>1</d2p1:int>

        <d2p1:int>2</d2p1:int>

    </IntLijst>

    <IntProperty>1</IntProperty>

    <SerializationID>0</SerializationID>

    <StringLijst xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">

        <d2p1:string>a</d2p1:string>

        <d2p1:string>b</d2p1:string>

    </StringLijst>

    <StringProperty>Ruurd Boeke</StringProperty>

    <StringProperty2>Boeke</StringProperty2>

    <OriginalValue_IntLijst xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">

        <d2p1:int>1</d2p1:int>

    </OriginalValue_IntLijst>

    <OriginalValue_IntProperty>1</OriginalValue_IntProperty>

    <OriginalValue_StringLijst xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">

        <d2p1:string>a</d2p1:string>

    </OriginalValue_StringLijst>

    <OriginalValue_StringProperty>Ruurd</OriginalValue_StringProperty>

    <OriginalValue_StringProperty2>Boeke</OriginalValue_StringProperty2>

</PersonSurrogate>

What is left, is deserializing, maybe propagating the beginedit commands to all children and then create the serverside EF variant.
Oh, and I don't like the originalValue representation. Maybe I'll generate a OriginalValue class to keep it tidy.