Le problème de référence circulaire n’est pas propre à Entity Framework mais plutôt
un problème de sérialisation WCF, dans cet article nous allons expliquer le problème
et proposer une solution.
Soit le modèle edmx suivant :
Ce modèle a été très bien conçu et reflète bien la réalité du métier, par contre pour
le développeur ce n’est pas vraiment la joie parce que s’il a envie de savoir à quel
StudentGroup appartient un étudiant (Person_Student) il devra passer par 4 tables
alors que c’est censé être l’opération métier la plus élémentaire. Passer par ces
4 tables est non seulement pénible pour le développeur mais en plus catastrophique
au niveau perf pour au final une opération très simple. Après une discussion houleuse
entre le Développeur et le DBA, le DBA accepte (une fois n’est pas coutume:)) d’ajouter
un raccourci matérialisé en une table de lien entre Student et StudentGroup permettant
de déterminer directement l’appartenance d’un étudiant à un groupe d’étudiants. Voici
ce qu’est devenu le modèle :
Si le DBA était retissant au rajout de ce raccourci c’est à cause de ce cycle (entouré
en rouge) introduit au sein du modèle. Ce cycle est sans conteste une mauvaise pratique
en design mais dans quelques cas ça s’avère bien pratique.
Tout content (juste parce qu’il a eu gain de cause:)), le développeur se met à développer
son service WCF en créant une méthode qui renvoie un étudiant en embarquant quelques
données liées. Voici le corps de la méthode :
public Person_Student GetById(int id)
{ SuiviScolaireEntities context = new SuiviScolaireEntities(); return context.Person_Student.Include("Pass")
.Include("Pass.Exam") .Include("Pass.Exam.Teach")
.Where(s => s.PersonId == id) .FirstOrDefault<Person_Student>(); }
Il crée ensuite la partie client pour appeler le service et en exécutant il obtient
l’erreur suivante :
Bon je vous l’accorde ce n’est pas très explicite comme erreur, pour y voir plus clair
nous allons activer
la trace WCF, voici la vrai erreur qui se cache derrière ce message :
There was an error while trying to serialize parameter
http://tempuri.org/:GetStudentByIdResult
.
The InnerException message was 'Object graph for type 'xxxxxxx' contains cycles and
cannot be serialized if reference tracking is disabled.'. Please see InnerException
for more details.
L’erreur dit que le modèle comporte un cycle et qu’il ne peut être sérialisé via WCF.
Le développeur la ramène moins d’un coup mais se dit qu’il faut absolument résoudre
ce problème pour ne pas avoir l’air con et que le DBA lui dise : je t’avais dit que
ce n’est pas bien!
Analyse du problème
Le problème est que le DataContractSerializer va vouloir sérialiser explicitement
les objets à renvoyer au client au lieu de travailler avec des références, supposons
que l’on ai ce modèle :
public
class Person
{ publicint Id { get; set; } publicint FirstName
{ get; set; } publicint LastName
{ get; set; } public List<Person> Enfants { get; set;
} }
Et que j’ai une List<Person> dans laquelle j’ai inséré des données de la manière
suivante :
Person pEnfant1 = new Person { Id
= 1, FirstName = "Thierry", LastName = "BOB" }; //Enfant Person
pEnfant2 = new Person { Id = 2, FirstName = "Marcus",
LastName = "TIBH" }; //Enfant Person
pEnfant3 = new Person { Id = 3, FirstName = "Adrien",
LastName = "MOLBE" }; //Enfant Person
pEnfant4 = new Person { Id = 4, FirstName = "Yam",
LastName = "BOB" }; //Enfant Person
pParent1 = new Person { Id = 5, FirstName = "Julien",
LastName = "BOB", Enfants = new List<Person>
{ pEnfant1, pEnfant4 } }; //Parent Person pParent2 = new Person
{ Id = 6, FirstName = "Gilian", LastName = "TIBH",
Enfants = new List<Person> { pEnfant2 } }; //Parent
Par défaut, le DataContractSerializer instancié par WCF sérialise les données de la
manière suivante :
<
ArrayOfPerson
xmlns
="http://schemas.datacontract.org/2004/07/ConsoleApplication1"
xmlns:i
="http://www.w3.org/2001/XMLSchema-instance"
>
<
Person
>
<
Enfants
i:nil
="true"
/>
<
FirstName
>Thierry</FirstName><Id>1</Id><LastName>BOB</LastName></Person><Person><Enfantsi:nil="true"/><FirstName>Marcus</FirstName><Id>2</Id><LastName>TIBH</LastName></Person><Person><Enfantsi:nil="true"/><FirstName>Adrien</FirstName><Id>3</Id><LastName>MOLBE</LastName></Person><Person><Enfantsi:nil="true"/><FirstName>Yam</FirstName><Id>4</Id><LastName>BOB</LastName></Person><Person><Enfants><Person><Enfantsi:nil="true"/><FirstName>Thierry</FirstName><Id>1</Id><LastName>BOB</LastName></Person><Person><Enfantsi:nil="true"/><FirstName>Yam</FirstName><Id>4</Id><LastName>BOB</LastName></Person></Enfants><FirstName>Julien</FirstName><Id>5</Id><LastName>BOB</LastName></Person><Person><Enfants><Person><Enfantsi:nil="true"/><FirstName>Marcus</FirstName><Id>2</Id><LastName>TIBH</LastName></Person></Enfants><FirstName>Gilian</FirstName><Id>6</Id><LastName>TIBH</LastName></Person></ArrayOfPerson>
Remarquez dans ce flux XML généré par le DataContractSerializer que les personnes
peuvent se répétées plusieurs fois dans le flux et que leur description entière est
reprise à chaque fois qu’elles apparaissent. Marcus TIBH apparaît dans le flux 2 fois
: Une fois comme “Person” sans enfants et ses informations sont reprises complètement
en tant que "Enfant” de Gilian TIBH.
En effet, par défaut, WCF instancie le DataContractSerializer avec la propriété preserveObjectReferences
= false. Cette propriété permet de spécifier de ne pas préserver les références d’objets
lors de la sérialisation et du coup répéter à chaque fois entièrement les données.
WCF n’autorise pas les références circulaires avec ce mode de sérialisation
et l’attribut preserveObjectReferences = false.
1ère Solution
La première solution est décrite dans le
blog de sowmy et qui consiste à modifier le fonctionnement par défaut de WCF en
instanciant le DataContractSerializer avec le preserveObjectReferences = true. Ceci
est possible en héritant de DataContractSerializerOperationBehavior et en surchargeant
sa méthode CreateSerializer qui renvoie le Serializer au moteur WCF. Nous pourrons
par la suite faire de notre classe un attribut avec lequel nous allons décorer toutes
les méthodes qui vont avoir besoin de ce mode de fonctionnement.
2ème solution
La deuxième méthode consiste à définir la propriété IsReference à True sur les classes
qui vont être sérialisés de cette manière :
[DataContract(IsReference=true)] publicclass Person
{ [DataMember] publicint Id {
get; set; } [DataMember] publicstring FirstName
{ get; set; } [DataMember] publicstring LastName
{ get; set; } [DataMember] public List<Person> Enfants
{ get; set; } }
De cette manière le DataContractSerializer va travailler avec les références à chaque
fois qu’il s’agit de sérialiser un objet du type de cette classe.
Pour ces 2 méthodes, voici le XML résultant :
<
ArrayOfPerson
xmlns
="http://schemas.datacontract.org/2004/07/ConsoleApplication1"
xmlns:i
="http://www.w3.org/2001/XMLSchema-instance"
>
<
Person
z:Id
="i1"
xmlns:z
="http://schemas.microsoft.com/2003/10/Serialization/"
>
<
Enfants
i:nil
="true"
/>
<
FirstName
>Thierry</FirstName><Id>1</Id><LastName>BOB</LastName></Person><Personz:Id="i2"xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Enfantsi:nil="true"/><FirstName>Marcus</FirstName><Id>2</Id><LastName>TIBH</LastName></Person><Personz:Id="i3"xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Enfantsi:nil="true"/><FirstName>Adrien</FirstName><Id>3</Id><LastName>MOLBE</LastName></Person><Personz:Id="i4"xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Enfantsi:nil="true"/><FirstName>Yam</FirstName><Id>4</Id><LastName>BOB</LastName></Person><Personz:Id="i5"xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Enfants><Personz:Ref="i1"/><Personz:Ref="i4"/></Enfants><FirstName>Julien</FirstName><Id>5</Id><LastName>BOB</LastName></Person><Personz:Id="i6"xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Enfants><Personz:Ref="i2"/></Enfants><FirstName>Gilian</FirstName><Id>6</Id><LastName>TIBH</LastName></Person></ArrayOfPerson>
Vous avez certainement remarqué les attributs z:Id et z:ref qui permettent de ne plus
reprendre toutes les données d’une instance et de la référencer via son Id.
Enjoy ;)
