Problème de redondance de liste après deserialization

Bonjour à tous,

Je débute en C# et j'ai bien besoin de votre aide. Il me semble que je passe à côté de quelque chose dans le fonctionnement d'une deserialization. J'essaie de concevoir un petit programme avec un objet Classe à sauvegarder, contenant des Eleve avec eux-mêmes un objet Competences, elle même construite avec plusieurs instances de la classe Competence sous forme d'une List<>.

Mais quand l'objet est instancié à partir d'une deserialization xml, la construction de la liste Competence se déclenche deux fois et l'ajout des compétences dans la liste se reproduit. Et j'aimerais éviter cette liste infinie de compétences redondantes en remplaçant la liste existante lors de la sauvegarde. Il me semble comprendre que le .Add est un problème mais je n'arrive pas à le contourner. J'ai essayé un Clear() en amont, ou de conditionner au nombre d'élément dans la liste, mais je n'obtiens qu'un tout ou rien. Je ne parviens pas non plus à remplacer plutôt qu'ajouter car la liste est considérée comme inexistante lors de la conception de la classe Competences.

Un bout de code sera sûrement plus clair :

Le point de départ

Code:

1
2
3
4
5
6
7
XmlSerializer xs = new XmlSerializer(typeof(Dt_Classes.Classe));
                using (StreamReader rd = new StreamReader(dossierGestion + '\\' + laCbBox.SelectedItem.ToString() + ".xml"))
                {
                    uneClasse = xs.Deserialize(rd) as Dt_Classes.Classe;
                    RefreshDataGrid(dgvLoad);
 
                }

La classe Classe

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Classe
    {
        private string _nomClasse;
 
        private List<Eleve> _lesEleves = new List<Eleve>();
 
        private List<Ilot> _lesIlots = new List<Ilot>();
 
        public string NomClasse { get { return _nomClasse; } set { _nomClasse = value; } }
        public List<Eleve> LesEleves { get { return _lesEleves; } set { _lesEleves = value; } }
 
        public Ilot[] LesIlots = new Ilot[8];
 
        public Classe()
        {
 
 
            NomClasse = _nomClasse;
            LesEleves = _lesEleves;
            for (int i = 1; i<=LesIlots.Length-1; i++)
            {
                LesIlots[i] = new Ilot();
                LesIlots[i].NomIlot = i;
            }
 
        }
 
        public void IntegrerIlot(Eleve eleve, int ilot)
        {
            LesEleves.Remove(eleve);
            LesIlots[ilot].ElevesIlots.Add(eleve);
 
 
        }
 
        public void QuitterIlot(Eleve eleve, int ilot)
        {
            LesIlots[ilot].ElevesIlots.Remove(eleve);
            LesEleves.Add(eleve);
        }
    }

La classe Eleve

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class Eleve
    {
        private string nomEleve;
 
        private string prenomEleve;
 
        private float ilot;
 
        private double _pointsOral;
 
        private Competences _sesCompetences = new Competences();
 
        [DisplayName("Nom")]
        public string Nom { get { return nomEleve; } set { nomEleve = value; } }
 
        [DisplayName("Prénom")]
        public string PrenomEleve { get { return prenomEleve; } set { prenomEleve = value; } }
 
        public float Ilot { get { return ilot; } set { ilot = value; } }
 
        public double PointsOral
        {
            get { return _pointsOral; }
            set { _pointsOral = value; }
        }
 
        public Competences SesCompetences { get { return _sesCompetences; } set { _sesCompetences = value; } }
 
 
        public Eleve()
 
        {
            Nom = nomEleve;
            PrenomEleve = prenomEleve;
            Ilot = ilot;
            PointsOral = _pointsOral;
            SesCompetences = _sesCompetences;
 
 
        }
 
        private void GagnePoints(double points)
        {
            _pointsOral += points;
        }
 
        public override string ToString()
        {
            return String.Format("Nom: {0} \n Prénom : {1} \n Points à l'oral : {2}", Nom, PrenomEleve, PointsOral);
        }
 
 
    }

Et la classe Competences

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
public class Competences
    {
        List<string> NomCompetencesOral = new List<string>();
        List<string> DomaineCompetencesOral = new List<string>();
 
        List<string> NomCompetencesComprehension = new List<string>();
        List<string> DomaineCompetencesComprehension = new List<string>();
 
        List<string> NomCompetencesEcriture = new List<string>();
        List<string> DomaineCompetencesEcriture = new List<string>();
 
        List<string> NomCompetencesLangue = new List<string>();
        List<string> DomaineCompetencesLangue = new List<string>();
 
        public List<Competence> CompetencesOral = new List<Competence>();
        public List<Competence> CompetencesComprehension = new List<Competence>();
        public List<Competence> CompetencesEcriture = new List<Competence>();
        public List<Competence> CompetencesLangue = new List<Competence>();
 
        public Competences()
        {
            // Initialisation des compétences du programme
 
            NomCompetencesOral.Add("Ecouter en maintenant son attention sur une période définie");
            DomaineCompetencesOral.Add("D1.1");
            NomCompetencesOral.Add("Écouter pour comprendre un message oral, un propos, un discours, un texte lu.");
            DomaineCompetencesOral.Add("D1.1");
            NomCompetencesOral.Add("Adopter une attitude critique par rapport à son auditoire.");
            DomaineCompetencesOral.Add("D2");
            NomCompetencesOral.Add("Enoncer un texte de mémoire.");
            DomaineCompetencesOral.Add("D1.1");
            NomCompetencesOral.Add("Parler en prenant en compte son auditoire.");
            DomaineCompetencesOral.Add("D3");
            NomCompetencesOral.Add("Participer à des échanges dans des situations diversifiées.");
            DomaineCompetencesOral.Add("D3");
            NomCompetencesOral.Add("Raconter une histoire.");
            DomaineCompetencesOral.Add("D1.1");
 
 
 
            for (int i =0; i<=NomCompetencesOral.Count-1; i++)
                {
                CompetencesOral.Add(new Competence());
                CompetencesOral[i].Name = NomCompetencesOral[i];
                CompetencesOral[i].Domaine = DomaineCompetencesOral[i];
                CompetencesOral[i].Points = 0;
                }

Le résultat problématique lors de la sauvegarde

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
<?xml version="1.0" encoding="utf-8"?>
<Classe xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <LesIlots>
    <Ilot xsi:nil="true" />
    <Ilot>
      <ElevesIlots />
      <NomIlot>1</NomIlot>
      <PointsIlot>0</PointsIlot>
    </Ilot>
    [...]
  </LesIlots>
  <NomClasse>4eD</NomClasse>
  <LesEleves>
    <Eleve>
      <Nom>Machin</Nom>
      <PrenomEleve>Trucmuche</PrenomEleve>
      <Ilot>0</Ilot>
      <PointsOral>0</PointsOral>
      <SesCompetences>
        <CompetencesOral>
          <Competence>
            <Name>Ecouter en maintenant son attention sur une période définie</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Écouter pour comprendre un message oral, un propos, un discours, un texte lu.</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Adopter une attitude critique par rapport à son auditoire.</Name>
            <Domaine>D2</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Enoncer un texte de mémoire.</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Parler en prenant en compte son auditoire.</Name>
            <Domaine>D3</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Participer à des échanges dans des situations diversifiées.</Name>
            <Domaine>D3</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Raconter une histoire.</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence>
// Le doublon qui se produit en boucle ici
          <Competence>
            <Name>Ecouter en maintenant son attention sur une période définie</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Écouter pour comprendre un message oral, un propos, un discours, un texte lu.</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Adopter une attitude critique par rapport à son auditoire.</Name>
            <Domaine>D2</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Enoncer un texte de mémoire.</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Parler en prenant en compte son auditoire.</Name>
            <Domaine>D3</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Participer à des échanges dans des situations diversifiées.</Name>
            <Domaine>D3</Domaine>
            <Points>0</Points>
          </Competence>
          <Competence>
            <Name>Raconter une histoire.</Name>
            <Domaine>D1.1</Domaine>
            <Points>0</Points>
          </Competence> 
[...] 
</Eleve>
  </LesEleves>
</Classe>

Je vous remercie de votre lecture et suis preneur de tout commentaire pour m'aider à progresser.

Bonjour,

Je ne sais pas si çà vous aidera à corriger votre problème, mais d'abord :

- Mettez l'attribut [Serializable] sur vos classes.
- Evitez les membres privées wrapper dans des propriétés publiques si celà ne sert à rien (utiliser directement get; set;)
- Pourquoi faire çà dans le constructeur, çà ne sert à rien ??? --> NomClasse = _nomClasse;
- Essayez de laisser le constructeur vide

Exemple (partiel) sur la class Classe :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
    [Serializable]
    class Classe
    {
        const int NOMBRE_ILOTS = 8;
 
        public string NomClasse { get; set; }
 
        public List<Eleve> LesEleves { get; set; }
 
        public List<Ilot> LesIlots { get; set; }
 
        public Classe()
        {
        }
 
        /// <summary>
        /// Initialise les Ilots à part
        /// </summary>
        public InitIlot()
        {
            LesIlots = new List<Ilot>();
 
            for (int i = 1; i <= NOMBRE_ILOTS - 1; i++)
            {
                LesIlots.Add(new Ilot()
                {
                    NomIlot = i.ToString()
                });
            }
        }
    }

Cdt,

Le doublon des compétences est logique le constructeur que tu as codé pour la classe Competences ajoute des compétences.
La sérialisation va donc procéder ainsi :
1. Création d'un Objet de type Classe et donc appel du constructeur Classe => Création des Ilots
2. Affectation des propriétés du type Classe
2.A. Affecte NomClasse avec le contenu du nœud <NomClasse>
2.B. Ilots n'est pas une propriété donc non affecté et c'est pour ça que tu n'a pas de doublons ici
2.C. Affecte Eleves et donc appel du constructeur de List (n'a pas d'impact)
2.C.Bis Parcours la liste des élèves dans le XML et pour nœud appelle le constructeur de Eleve => Créations des Eleves
3. Affectation des propriété du type Eleve
3.A. Affecte la propriété Nom avec le contenu du nœud <Nom>
3.B. Idem pour Prénom
3.C. Idem pour Ilot
3.E. Idem pour PointOral
3.F. Affecte la propriété SesCompetences avec un objet de type Competences et donc appel du constructeur de Competences => Création de compétences par le constructeur de Competences
3.F.Bis Parcours la liste des compétences dans le XML et pour nœud ajoute une compétence => Créations de compétences en doublons par la lecture du XML.

Un grand merci à tous les deux ! Aussi bien pour les corrections que pour la décomposition très claire :mrgreen:. Je comprends mieux ce qui se passe et le problème que posent mes constructeurs.