[Linq To SQL] Insertion non voulue

**LE NEINDRE** · 27/10/2008, 10h49

Bonjour à tous,
Voilà mon problème:
J'ai un ficheir xml que je lis et à partir duquel je créer des objets du type d'une table de ma base de données.
Voici un exemple ci-dessous:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
            var m_xmlEngineInfos = (from responseByCulture in xdVersions
                                from version in responseByCulture.Response.Elements("Version")
                                let description = version.Element("EngineElt").Attribute("description")
                                select new EngineInfo
                                {
                                    Culture = responseByCulture.Culture,
                                    IdEngine = version.Element("EngineElt").Attribute("id").Value,
                                    Label = version.Element("EngineElt").Attribute("label").Value,
                                    Description = (description != null) ? description.Value : string.Empty,
                                })
                              .GroupBy(x => new { x.IdEngine, x.IdCulture }).Select(x => x.First())
                              .ToList();

Et bien si j'ai le malheur de faire un submitChanges() sur mon datacontext, tous les éléments sont insérés en base de données !!
Je n'ai pourtant pas fait de dc.InsertAllOnsubmit(m_xmlEngineInfos).
Comment cela se fait il ?

Merci d'avance pour vos lumières !!

**Jérôme Lambert** · 27/10/2008, 11h06

Juste après le code que tu as donné, tu pourrais écrire le code qui permet de récupérer le ChangeSet, soit :

Code :

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

System.Data.Linq.ChangeSet changes = ct.GetChangeSet();

Le ChangeSet n'est pas censé contenir tes objets... A mon avis, involontairement, tu les ajoutes plus tard dans ton datacontext mais bon, sans plus de code, si difficile de répérer où est ton erreur.

**LE NEINDRE** · 27/10/2008, 11h41

Bonjour Jérôme,
Merci pour cette réponse rapide.
Le changeSet me donne le résultat suivant:

Code :

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

1
2
3
 
 
Inserts:489;Deletes:0;Updates;0

placé juste avant la requête que j'ai écrit dans le premier post, le changeSet est vide.

C'est donc bien cette requête qui insère les 489 objets EngineInfos dans la dataContext.
On est bien d'accord que tant qu'un InsertOnSubmit ou un InsertAllOnSubmit n'est pas appelé, le datacontext n'est pas rempli.

Ici, il semblerait que le seul fait de créer l'objet EngineInfo, rajoute l'objet dans le datacontext.

Pour info, je te donne la définition de la classe EngineInfo auto-générée:

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
 
 
	[Table(Name="dbo.EngineInfo")]
	public partial class EngineInfo : INotifyPropertyChanging, INotifyPropertyChanged
	{
 
		private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
 
		private int _IdEngineInfo;
 
		private int _IdCulture;
 
		private string _IdEngine;
 
		private string _Label;
 
		private string _Description;
 
		private string _Description_overriden;
 
		private EntityRef<Culture> _Culture;
 
		private EntityRef<Engine> _Engine;
 
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(System.Data.Linq.ChangeAction action);
    partial void OnCreated();
    partial void OnIdEngineInfoChanging(int value);
    partial void OnIdEngineInfoChanged();
    partial void OnIdCultureChanging(int value);
    partial void OnIdCultureChanged();
    partial void OnIdEngineChanging(string value);
    partial void OnIdEngineChanged();
    partial void OnLabelChanging(string value);
    partial void OnLabelChanged();
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    partial void OnDescription_overridenChanging(string value);
    partial void OnDescription_overridenChanged();
    #endregion
 
		public EngineInfo()
		{
			this._Culture = default(EntityRef<Culture>);
			this._Engine = default(EntityRef<Engine>);
			OnCreated();
		}
 
		[Column(Storage="_IdEngineInfo", AutoSync=AutoSync.OnInsert, DbType="Int NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
		public int IdEngineInfo
		{
			get
			{
				return this._IdEngineInfo;
			}
			set
			{
				if ((this._IdEngineInfo != value))
				{
					this.OnIdEngineInfoChanging(value);
					this.SendPropertyChanging();
					this._IdEngineInfo = value;
					this.SendPropertyChanged("IdEngineInfo");
					this.OnIdEngineInfoChanged();
				}
			}
		}
 
		[Column(Storage="_IdCulture", DbType="Int NOT NULL")]
		public int IdCulture
		{
			get
			{
				return this._IdCulture;
			}
			set
			{
				if ((this._IdCulture != value))
				{
					if (this._Culture.HasLoadedOrAssignedValue)
					{
						throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
					}
					this.OnIdCultureChanging(value);
					this.SendPropertyChanging();
					this._IdCulture = value;
					this.SendPropertyChanged("IdCulture");
					this.OnIdCultureChanged();
				}
			}
		}
 
		[Column(Storage="_IdEngine", DbType="Char(2) NOT NULL", CanBeNull=false)]
		public string IdEngine
		{
			get
			{
				return this._IdEngine;
			}
			set
			{
				if ((this._IdEngine != value))
				{
					if (this._Engine.HasLoadedOrAssignedValue)
					{
						throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
					}
					this.OnIdEngineChanging(value);
					this.SendPropertyChanging();
					this._IdEngine = value;
					this.SendPropertyChanged("IdEngine");
					this.OnIdEngineChanged();
				}
			}
		}
 
		[Column(Storage="_Label", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
		public string Label
		{
			get
			{
				return this._Label;
			}
			set
			{
				if ((this._Label != value))
				{
					this.OnLabelChanging(value);
					this.SendPropertyChanging();
					this._Label = value;
					this.SendPropertyChanged("Label");
					this.OnLabelChanged();
				}
			}
		}
 
		[Column(Storage="_Description", DbType="NVarChar(MAX)")]
		public string Description
		{
			get
			{
				return this._Description;
			}
			set
			{
				if ((this._Description != value))
				{
					this.OnDescriptionChanging(value);
					this.SendPropertyChanging();
					this._Description = value;
					this.SendPropertyChanged("Description");
					this.OnDescriptionChanged();
				}
			}
		}
 
		[Column(Storage="_Description_overriden", DbType="NVarChar(MAX)")]
		public string Description_overriden
		{
			get
			{
				return this._Description_overriden;
			}
			set
			{
				if ((this._Description_overriden != value))
				{
					this.OnDescription_overridenChanging(value);
					this.SendPropertyChanging();
					this._Description_overriden = value;
					this.SendPropertyChanged("Description_overriden");
					this.OnDescription_overridenChanged();
				}
			}
		}
 
		[Association(Name="Culture_EngineInfo", Storage="_Culture", ThisKey="IdCulture", OtherKey="IdCulture", IsForeignKey=true)]
		public Culture Culture
		{
			get
			{
				return this._Culture.Entity;
			}
			set
			{
				Culture previousValue = this._Culture.Entity;
				if (((previousValue != value) 
							|| (this._Culture.HasLoadedOrAssignedValue == false)))
				{
					this.SendPropertyChanging();
					if ((previousValue != null))
					{
						this._Culture.Entity = null;
						previousValue.EngineInfos.Remove(this);
					}
					this._Culture.Entity = value;
					if ((value != null))
					{
						value.EngineInfos.Add(this);
						this._IdCulture = value.IdCulture;
					}
					else
					{
						this._IdCulture = default(int);
					}
					this.SendPropertyChanged("Culture");
				}
			}
		}
 
		[Association(Name="Engine_EngineInfo", Storage="_Engine", ThisKey="IdEngine", OtherKey="IdEngine", IsForeignKey=true)]
		public Engine Engine
		{
			get
			{
				return this._Engine.Entity;
			}
			set
			{
				Engine previousValue = this._Engine.Entity;
				if (((previousValue != value) 
							|| (this._Engine.HasLoadedOrAssignedValue == false)))
				{
					this.SendPropertyChanging();
					if ((previousValue != null))
					{
						this._Engine.Entity = null;
						previousValue.EngineInfos.Remove(this);
					}
					this._Engine.Entity = value;
					if ((value != null))
					{
						value.EngineInfos.Add(this);
						this._IdEngine = value.IdEngine;
					}
					else
					{
						this._IdEngine = default(string);
					}
					this.SendPropertyChanged("Engine");
				}
			}
		}
 
		public event PropertyChangingEventHandler PropertyChanging;
 
		public event PropertyChangedEventHandler PropertyChanged;
 
		protected virtual void SendPropertyChanging()
		{
			if ((this.PropertyChanging != null))
			{
				this.PropertyChanging(this, emptyChangingEventArgs);
			}
		}
 
		protected virtual void SendPropertyChanged(String propertyName)
		{
			if ((this.PropertyChanged != null))
			{
				this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
			}
		}
	}

J'avoue que là je suis complétement perdu ...

et ne sais plus quoi faire ....

**LE NEINDRE** · 27/10/2008, 13h51

Bon alors j'ai résolu mon problème par hasard en construisant mon objet EngineInfo différemment.

Dans le premier cas, je construisais EngineInfo ainsi:

Code :

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

1
2
3
4
5
6
7
8
9

select new EngineInfo
{
       Culture = responseByCulture.Culture,
       IdEngine = version.Element("EngineElt").Attribute("id").Value,
       Label = version.Element("EngineElt").Attribute("label").Value,
       Description = (description != null) ? description.Value : string.Empty,
};

En assignant ainsi culture, je déclenchais l'ajout de EngineInfo dans le dataContext et me retrouvais donc avec 489 éléments insérés.

Dans le second cas, je construis EngineInfo ainsi:

Code :

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

1
2
3
4
5
6
7
8
9
10


select new EngineInfo
{
       IdCulture = responseByCulture.Culture.IdCulture,
       IdEngine = version.Element("EngineElt").Attribute("id").Value,
       Label = version.Element("EngineElt").Attribute("label").Value,
       Description = (description != null) ? description.Value : string.Empty,
};

Là aucun éléments n'est inséré dans le datacontext.

PS: La table Culture et EngineInfo sont liés, la table EngineInfo possède dans ses attributs la clé étrangère de Culture.

Je crois à peu près comprendre ce qu'il se passe mais si quelqu'un a des explications plus claires que ce qu'il y a dans ma tête, je suis preneur !!

[Linq To SQL] Insertion non voulue

Accès aux données

Discussions similaires

Partager

Partager