Discussion :

[Spikuria]

Bonjour à tous !

Voilà, j'essaie désespérément de créer une relation one to many dans mon code C# mais la liste qui est censée contenir les "many" n'est jamais créée. Je suppose que j'ai oublié quelque chose quelque part car comme je l'ai fait ça serait un peu magique que ça fonctionne, mais je ne sais pas quoi rajouter ni où ^^

Ma base de données est sous oracle. J'ai ces 3 tables :
TB_ESPFONC : CodeEspFonc, Libelle
TB_CRITERE : CodeCritere, libelle, CodeEspFonc (clé étrangère référençant CodeEspFonc de TB_ESPFONC)
TB_SOUSCRITERE : CodeSousCritere, libelle, CodeCritere (pareil mais avec TB_CRITERE)

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
[Class(Table = "TB_ESPFONC", Name = "DataObjects.EspFoncDO, DataObjects")]
    public class EspFoncDO : AbstractDO {
        #region Attributs
        private new int id;
        private string libelleEspFonc;
        #endregion
 
        #region Propriétés & Mapping
        /// <summary>
        /// Id
        /// </summary>
        /// <value>Id</value>
        [Id(0, Column = "CODEESPFONC", TypeType = typeof(int), Name = "Id")]
        [Generator(1, Class = "assigned")]
        public new virtual int Id
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
 
        /// <summary>
        /// LibelleEspFonc
        /// </summary>
        /// <value>LibelleEspFonc</value>
        [Property(Column = "LIBELLE")]
        public virtual string LibelleEspFonc
        {
            get
            {
                return libelleEspFonc;
            }
            set
            {
                libelleEspFonc = value;
            }
        }
 
        private IList<CritereDO> criteres;
 
        /// <summary>
        /// Liste des criteres lies a cet espace/fonction
        /// </summary>
        [Bag(0, Table = "TB_CRITERE", Lazy = false)]
        [Key(1, Column = "CODEESPFONC")]
        [OneToMany(2, Class = "DataObjects.CritereDO, DataObjects")]
        public virtual IList<CritereDO> Criteres
        {
            get { return criteres; }
            set { criteres = value; }
        }
 
        #endregion
    }

J'ai fait la même chose pour Critere et SousCritère, je ne vais pas inonder le sujet de code ^^

J'ai ensuite cette 2ème classe qui est presque la même que la 1ère mais qui sera celle que je vais utiliser après :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class EspFoncVO : AbstractVO
    {
        #region Converteurs et constructeurs
        /// <summary>
        /// Crée une nouvelle instance de <see cref="EspFoncVO"/>.
        /// </summary>
        public EspFoncVO()
        {
        }
 
        /// <summary>
        /// Permet la création d'un VO à partir d'un objet connecté
        /// </summary>
        /// <param name="espFonc">espFonc</param>
        public EspFoncVO(EspFoncDO espFonc)
        {
            this.id = espFonc.Id;
            this.libelleEspFonc = espFonc.LibelleEspFonc;
        }
 
        /// <summary>
        /// Permet de caster un VO en DO
        /// </summary>
        /// <param name="espFonc">espFonc</param>
        /// <returns>EspFoncDO</returns>
        public static implicit operator EspFoncDO(EspFoncVO espFonc)
        {
            EspFoncDO espFoncDO = new EspFoncDO();
            espFoncDO.Id = espFonc.Id;
            espFoncDO.LibelleEspFonc = espFonc.libelleEspFonc;
            return espFoncDO;
        }
        #endregion
 
        #region LazyLoaded
        private IList<CritereVO> criteres;
 
        /// <summary>
        /// Liste des criteres lies a cet espace/fonction
        /// </summary>
        public virtual IList<CritereVO> Criteres
        {
            get { return criteres; }
            set { criteres = value; }
        }
        #endregion
 
        #region Attributs
        private int id;
        private string libelleEspFonc;
        #endregion
 
        #region Accesseurs
        /// <summary>
        /// CodeEspFonc
        /// </summary>
        /// <value>CodeEspFonc</value>
        public int Id
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
 
        /// <summary>
        /// LibelleEspFonc
        /// </summary>
        /// <value>LibelleEspFonc</value>
        public string LibelleEspFonc
        {
            get
            {
                return libelleEspFonc;
            }
            set
            {
                libelleEspFonc = value;
            }
        }
 
        #endregion
    }

Vient enfin le bout de code qui me génère mon exception "NullReferenceException" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
foreach (EspFoncVO espace in DataProvider.GetEspFoncData()) {
   foreach (CritereVO critere in espace.Criteres) { ...... }
}

C'est mon champ Criteres qui est à null, ce que je conçois parfaitement car je ne vois pas où initialiser ni comment ^^ Sachant que GetEspFoncData() retourne une liste de EspFoncVO qui elle est bien initialisée, mais par mes soins :/

Voilà, si quelqu'un à une suggestion, je suis ouverte =D

Merci d'avance !

[B.AF]

Ben peut être qu'il faudrait que tu
- initialises la collection
- que tu copies la collection concernée, ce qui n'est pas le cas

Ton cast implicite fonctionne bien, sauf que si tu regardes ta classe, elle ne gére pas du tout la propriété Criteres :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
        #region Converteurs et constructeurs
        /// <summary>
        /// Crée une nouvelle instance de <see cref="EspFoncVO"/>.
        /// </summary>
        public EspFoncVO()
        {
        }
 
        /// <summary>
        /// Permet la création d'un VO à partir d'un objet connecté
        /// </summary>
        /// <param name="espFonc">espFonc</param>
        public EspFoncVO(EspFoncDO espFonc)
        {
            this.id = espFonc.Id;
            this.libelleEspFonc = espFonc.LibelleEspFonc;
        }
 
        /// <summary>
        /// Permet de caster un VO en DO
        /// </summary>
        /// <param name="espFonc">espFonc</param>
        /// <returns>EspFoncDO</returns>
        public static implicit operator EspFoncDO(EspFoncVO espFonc)
        {
            EspFoncDO espFoncDO = new EspFoncDO();
            espFoncDO.Id = espFonc.Id;
            espFoncDO.LibelleEspFonc = espFonc.libelleEspFonc;
            return espFoncDO;
        }
 
(...)
 
private IList<CritereVO> criteres;
 
        /// <summary>
        /// Liste des criteres lies a cet espace/fonction
        /// </summary>
        public virtual IList<CritereVO> Criteres
        {
            get { return criteres; }
            set { criteres = value; }
        }

Quelle que soit l'instance d'EspFoncVO que tu crées, criteres est null, donc .Criteres te génére une nulle référence exception.
Et la liste n'existe pas.
Je ne vois pas trop l'utilité de faire un objet copie dans ce cas.
Si vraiment tu veux avoir des objets légers et des objets plus lourds,
Autant raisonner en service et ne pas mapper d'associations, ou créer plusieurs objets.