循环引用的DataContract序列化对于集合的第一项来说作用太深，而对其余项的作用太细

Question

I have two classes which refer on each other:

[DataContract(IsReference = true)]
public class Student
{
    [DataMember]
    public int Id { get; set; }

    [DataMember]
    public string Name { get; set; }

    [DataMember]
    public string Surname { get; set; }

    [DataMember]
    public List<Course> Courses { get; set; }

    public Student()
    {
        Courses = new List<Course>();
    }
}


[DataContract(IsReference = true)]
public class Course
{
    [DataMember]
    public int Id { get; set; }

    [DataMember]
    public string Name { get; set; }

    [DataMember]
    public List<Student> Students { get; set; }

    public Course()
    {
        Students = new List<Student>();
    }
}

I want to serialize 4 Student entities, each of them has some courses attached. after serialization only the first Student entity appears not empty. What is more, it has too many reference levels. And all others Student entities are empty:

<GetStudentsResult         
xmlns:a="http://schemas.datacontract.org/2004/07/WcfService2" 
xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" 
z:Id="i1">
<a:Courses>
<a:Course z:Id="i2">
<a:Id>1</a:Id>
<a:Name>Operation Systems</a:Name>
<a:Students>
<a:Student z:Ref="i1"/>
<a:Student z:Id="i3">
<a:Courses>
<a:Course z:Ref="i2"/>
<a:Course z:Id="i4">
<a:Id>2</a:Id>
<a:Name>Algorithmes and data structures</a:Name>
<a:Students>
<a:Student z:Ref="i3"/>
<a:Student z:Id="i5">
<a:Courses>
<a:Course z:Ref="i4"/>
<a:Course z:Id="i6">
<a:Id>3</a:Id>
<a:Name>Basics of HTML and CSS</a:Name>
<a:Students>
<a:Student z:Ref="i1"/>
<a:Student z:Id="i7">
<a:Courses>
<a:Course z:Ref="i2"/>
<a:Course z:Ref="i6"/>
</a:Courses>
<a:Id>3</a:Id>
<a:Name>Oleg</a:Name>
<a:Surname>Kuznetsov</a:Surname>
</a:Student>
<a:Student z:Ref="i5"/>
</a:Students>
</a:Course>
</a:Courses>
<a:Id>4</a:Id>
<a:Name>Olga</a:Name>
<a:Surname>Petrova</a:Surname>
</a:Student>
</a:Students>
</a:Course>
</a:Courses>
<a:Id>2</a:Id>
<a:Name>Maria</a:Name>
<a:Surname>Vasilyeva</a:Surname>
</a:Student>
<a:Student z:Ref="i7"/>
</a:Students>
</a:Course>
<a:Course z:Ref="i6"/>
</a:Courses>
<a:Id>1</a:Id>
<a:Name>Egor</a:Name>
<a:Surname>Ivanov</a:Surname>
</a:Student>
<a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"
z:Ref="i3"/>
<a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"     
z:Ref="i7"/>
<a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"     
z:Ref="i5"/>
</GetStudentsResult>

Here is my code, filling Student and Course collections:

Student s1 = new Student { Id = 1, Name = "Egor", Surname = "Ivanov" };
        Student s2 = new Student { Id = 2, Name = "Maria", Surname = "Vasilyeva" };
        Student s3 = new Student { Id = 3, Name = "Oleg", Surname = "Kuznetsov" };
        Student s4 = new Student { Id = 4, Name = "Olga", Surname = "Petrova" };

        context.Students.Add(s1);
        context.Students.Add(s2);
        context.Students.Add(s3);
        context.Students.Add(s4);

        Course c1 = new Course
        {
            Id = 1,
            Name = "Operation Systems",
            Students = new List<Student>() { s1, s2, s3 }
        };
        Course c2 = new Course
        {
            Id = 2,
            Name = "Algorithmes and data structures",
            Students = new List<Student>() { s2, s4 }
        };
        Course c3 = new Course
        {
            Id = 3,
            Name = "Basics of HTML and CSS",
            Students = new List<Student>() { s3, s4, s1 }
        };

        context.Courses.Add(c1);
        context.Courses.Add(c2);
        context.Courses.Add(c3);

Please advise.

Answer 1

What you are seeing is not a bug. The IsReference = true functionality of the data contract serializers never creates forward declarations in the XML file, only backwards references. Let's take a simple case:

[DataContract(IsReference = true, Namespace="")]
public class Item
{
    [DataMember]
    public int Id { get; set; }
    [DataMember]
    public Item SubItem { get; set; }
}

public class TestClass
{
    public static void TestSimple()
    {
        var item1 = new Item { Id = 1 };
        var item2 = new Item { Id = 2 };
        item1.SubItem = item2;

        var xml = DataContractSerializerHelper.GetXml(new[] { item1, item2 });

        Debug.WriteLine(xml);
    }
}

The XML created by this test case is looks like:

<ArrayOfItem xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
    <Item z:Id="i1" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
        <Id>1</Id>
        <SubItem z:Id="i2">
            <Id>2</Id>
            <SubItem i:nil="true" />
        </SubItem>
    </Item>
    <Item z:Ref="i2" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" />
</ArrayOfItem>

What this means is:

• The first time item1 is encountered is in the root list. It gets assigned a reference id z:Id="i1"
• The first time item2 is encountered is as a child of item1 . It gets assigned a reference id z:Id="i2"
• The second time item2 is encountered is in the root list. In that case, it appears only as an indirect reference z:Id="i2" .

Ie, when serializing, the first time the data contract serializer encounters a reference object, it assigns it a reference id, saves that id in a dictionary, and proceeds to serialize the object. Then, on subsequent encounters, it serializes a reference to that id, and nothing else. Then, when deserializing, it does the reverse: when a reference id is encountered as an attribute of an element, the object created for that element is put in a dictionary, then is deserialized. On subsequent encounters to that id, the saved object is taken from the dictionary and inserted in the object graph.

This simple one-pass algorithm does not allow for forward declarations.

It appears that you would prefer that reference objects be serialized at the highest possible level in the XML with forwards or backwards references inserted as needed in nested elements, like so:

<ArrayOfItem xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
    <Item z:Id="i1" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
        <Id>1</Id>
        <SubItem z:Ref="i2"/> <!-- FORWARD DECLARATION OF z:Id="i2" -->
    </Item>
    <Item z:Id="i2" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
        <Id>2</Id>
        <SubItem i:nil="true" />
    </Item>
</ArrayOfItem>

Unfortunately, the data contact serializer doesn't do that.

You can see that, by indenting your XML, all students are properly included -- all but the first as nested elements of the list of courses of the first student. Then subsequent occurrences are just references:

<GetStudentsResult xmlns:a="http://schemas.datacontract.org/2004/07/WcfService2" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
   <a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" z:Id="i1">
      <a:Courses>
         <a:Course z:Id="i2">
            <a:Id>1</a:Id>
            <a:Name>Operation Systems</a:Name>
            <a:Students>
               <a:Student z:Ref="i1" />
               <a:Student z:Id="i3">
                  <a:Courses>
                     <a:Course z:Ref="i2" />
                     <a:Course z:Id="i4">
                        <a:Id>2</a:Id>
                        <a:Name>Algorithmes and data structures</a:Name>
                        <a:Students>
                           <a:Student z:Ref="i3" />
                           <a:Student z:Id="i5">
                              <a:Courses>
                                 <a:Course z:Ref="i4" />
                                 <a:Course z:Id="i6">
                                    <a:Id>3</a:Id>
                                    <a:Name>Basics of HTML and CSS</a:Name>
                                    <a:Students>
                                       <a:Student z:Ref="i1" />
                                       <a:Student z:Id="i7">
                                          <a:Courses>
                                             <a:Course z:Ref="i2" />
                                             <a:Course z:Ref="i6" />
                                          </a:Courses>
                                          <a:Id>3</a:Id>
                                          <a:Name>Oleg</a:Name>
                                          <a:Surname>Kuznetsov</a:Surname>
                                       </a:Student>
                                       <a:Student z:Ref="i5" />
                                    </a:Students>
                                 </a:Course>
                              </a:Courses>
                              <a:Id>4</a:Id>
                              <a:Name>Olga</a:Name>
                              <a:Surname>Petrova</a:Surname>
                           </a:Student>
                        </a:Students>
                     </a:Course>
                  </a:Courses>
                  <a:Id>2</a:Id>
                  <a:Name>Maria</a:Name>
                  <a:Surname>Vasilyeva</a:Surname>
               </a:Student>
               <a:Student z:Ref="i7" />
            </a:Students>
         </a:Course>
         <a:Course z:Ref="i6" />
      </a:Courses>
      <a:Id>1</a:Id>
      <a:Name>Egor</a:Name>
      <a:Surname>Ivanov</a:Surname>
   </a:Student>
   <a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" z:Ref="i3" />
   <a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" z:Ref="i7" />
   <a:Student xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" z:Ref="i5" />
</GetStudentsResult>

If you deserialize that XML with DataContractSerializer , you will find your graph of students and courses correctly restored with the same topology as the original graph.