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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
|
/// <summary>
/// Hilfs-Funktionen zum Konvertieren von Recordsets in DataTables und umgekehrt.
/// </summary>
public class RecordsetBridge
{
/// <summary>
/// Erzeugt ein Recordset-Skelett aus einer DataTable.
/// </summary>
/// <param name="table">DataTable</param>
/// <returns>Recordset-Skelett (Ohne Daten)</returns>
public static ADODB.Recordset CreateRecordsetSkeletonFromDataTable(DataTable table)
{
// Neues Recordset erzeugen
ADODB.Recordset rs = new ADODB.RecordsetClass();
// Alle Spalten der DataTable durchlaufen
foreach (DataColumn column in table.Columns)
{
// Feld an Recordset anfügen
rs.Fields._Append(column.ColumnName, GetADODBDataTypeFromDataColumn(column), column.MaxLength, ADODB.FieldAttributeEnum.adFldMayBeNull);
}
// Recordset öffenen
rs.Open(System.Reflection.Missing.Value, System.Reflection.Missing.Value, ADODB.CursorTypeEnum.adOpenUnspecified, ADODB.LockTypeEnum.adLockUnspecified, (Int32)(0));
// Recordset zurückgeben
return rs;
}
/// <summary>
/// Wandelt eine DataTable in ein Recordset um.
/// <remarks>
/// Achtung! Die Zustände der einzelnen Zeilen (Added, Modified, Deleted, etc.)
/// werden nicht ins Ziel Recordset übernommen. Recordsets bieten keine
/// technische Möglichkeit, um Zeilenzustände zu übernehmen.
/// </remarks>
/// </summary>
/// <param name="table">DataTable</param>
/// <returns>Recordset</returns>
public static ADODB.Recordset ConvertDataTableToRecordset(DataTable table)
{
// Recordset-Skelett aus der angegebenen DataTable erzeugen
ADODB.Recordset rs = CreateRecordsetSkeletonFromDataTable(table);
// Hashtable für ADODB.Field Instanzen erzeugen
Hashtable fields = new Hashtable(table.Columns.Count);
// Alle Spalten der DataTable durchlaufen
foreach (DataColumn column in table.Columns)
{
// Spalte im Recordset-Skelett suchen und zur Hashtable zufügen
ADODB.Field field = rs.Fields[column.ColumnName];
fields.Add(column.ColumnName, field);
}
// Alle Zeilen der DataTable durchlaufen
foreach (DataRow row in table.Rows)
{
// Neuen Datensatz im Recordset erzeugen
rs.AddNew(System.Reflection.Missing.Value, System.Reflection.Missing.Value);
// Alle Spalten der DataTable durchlaufen
foreach (DataColumn column in table.Columns)
{
// Recordset-Feld aus der Hashtable über den Spaltennamen abrufen
ADODB.Field field = (ADODB.Field)(fields[column.ColumnName]);
// Zellenwert in Recordset schreiben
field.Value = row[column];
}
}
// Wenn Datensätze übernommen wurden ...
if (rs.RecordCount > 0)
{
// Feldwerte übernehmen
rs.UpdateBatch(ADODB.AffectEnum.adAffectAll);
// Zum ersten Datensatz springen
rs.MoveFirst();
}
// Hashtable leeren
fields.Clear();
// Recordset zurückgeben
return rs;
}
/// <summary>
/// Gibt den passenden ADODB-Datentyp-Auflistungswert einer bestimmten DataTable-Spalte zurück.
/// </summary>
/// <param name="column">Spalte einer DataTable</param>
/// <returns>ADO-Datentyp-Auflistugswert</returns>
public static ADODB.DataTypeEnum GetADODBDataTypeFromDataColumn(DataColumn column)
{
// CLR Datentyp auswerten
switch (column.DataType.Name.ToLower())
{
case "guid": // Eindeutiger Bezeichner
return ADODB.DataTypeEnum.adVariant;
case "boolean": // Boolean
return ADODB.DataTypeEnum.adBoolean;
case "bool": // Boolean
return ADODB.DataTypeEnum.adBoolean;
case "byte": // Byte
return ADODB.DataTypeEnum.adUnsignedTinyInt;
case "char": // Char
return ADODB.DataTypeEnum.adChar;
case "datetime": // DateTime
return ADODB.DataTypeEnum.adDate;
case "decimal": // Decimal
return ADODB.DataTypeEnum.adDecimal;
case "double": // Double
return ADODB.DataTypeEnum.adDouble;
case "int16": // Int16
return ADODB.DataTypeEnum.adSmallInt;
case "int32": // Int32
return ADODB.DataTypeEnum.adInteger;
case "int64": // Int64
return ADODB.DataTypeEnum.adBigInt;
case "sbyte": // SByte
return ADODB.DataTypeEnum.adTinyInt;
case "single": // Single
return ADODB.DataTypeEnum.adSingle;
case "string": // String
// Wenn die maximale Feldlänge größer als 4000 ist ...
if (column.MaxLength > 4000)
{
// Langer Text (ntext)
return ADODB.DataTypeEnum.adLongVarWChar;
}
else
{
// Normaler Text (nvarchar)
return ADODB.DataTypeEnum.adVarWChar;
}
case "timespan": // TimeSpan
return ADODB.DataTypeEnum.adBigInt;
case "uint16": // UInt16
return ADODB.DataTypeEnum.adUnsignedSmallInt;
case "uint32": // UInt32
return ADODB.DataTypeEnum.adUnsignedInt;
case "uint64": // UInt64
return ADODB.DataTypeEnum.adUnsignedBigInt;
}
// Undefinierten Typ zurückgeben
return ADODB.DataTypeEnum.adVariant;
}
/// <summary>
/// Wandelt ein Recordset in eine DataTable um.
/// <remarks>
/// Der aktuelle Zustand der einzelnen Datensätze wird korrekt übernommen.
/// Wenn am Recordset noch nicht UpdateBatch aufgerufen wurde, werden
/// z.B. gelöschte Datensätze in DataRows mit RowState "Deleted" konvertiert.
/// </remarks>
/// </summary>
/// <param name="rs">Recordset</param>
/// <returns>DataTable</returns>
public static DataTable ConvertRecordsetToDataTable(ADODB.Recordset rs)
{
// DataTable-Skelett aus Recordset erzeugen
DataTable table = CreateDataTableSkeletonFromRecordset(rs);
// Filter zurücksetzen
rs.Filter = ADODB.FilterGroupEnum.adFilterNone;
// Zum ersten Datensatz springen
if (!rs.EOF) rs.MoveFirst();
// Alle Recordset-Datensätze durchlaufen
while (!rs.EOF)
{
// Importieren wenn Status "Unchanged" ist
if (rs.Status == 8) ImportUnchangedRow(table, rs);
// Zum nächsten Datensatz springen
rs.MoveNext();
}
// Geänderte Datensätze filtern
rs.Filter = ADODB.FilterGroupEnum.adFilterPendingRecords;
// Zum ersten Datensatz springen
if (!rs.EOF) rs.MoveFirst();
// Alle Recordset-Datensätze durchlaufen
while (!rs.EOF)
{
// Datensatz importieren
ImportRowFromRecordset(table, rs);
// Zum nächsten Datensatz springen
rs.MoveNext();
}
// die Tabelle zurückgeben
return table;
}
/// <summary>
/// Übernimmt einen Datensatz aus einem RecordSet in eine bestimmte DataTable.
/// </summary>
/// <param name="table">Ziel-DataTable</param>
/// <param name="rs">Quell-RecordSet</param>
private static void ImportRowFromRecordset(DataTable table, ADODB.Recordset rs)
{
// Status des aktuellen Recordset-Datensatzes auswerten
switch (rs.Status)
{
case 1: // ADODB.RecordStatusEnum.adRecNew
// Als neu zugefügte Zeile importieren
ImportAddedRow(table, rs);
break;
case 2: // ADODB.RecordStatusEnum.adRecModified
// Als geänderte Zeile importieren
ImportModifiedRow(table, rs);
break;
case 4: // ADODB.RecordStatusEnum.adRecDeleted
// Als gelöschte Zeile importieren
ImportDeletedRow(table, rs);
break;
case 8: // ADODB.RecordStatusEnum.adRecUnchanged
// Als ungeänderte Zeile importieren
ImportUnchangedRow(table, rs);
break;
}
}
/// <summary>
/// Fügt einen im Recordset neu eingefügten Datensatz einer DataTable zu.
/// </summary>
/// <param name="table">Ziel-DataTable</param>
/// <param name="rs">Quell-RecordSet</param>
private static void ImportAddedRow(DataTable table, ADODB.Recordset rs)
{
// Neue DataTable-Zeile erzeugen
DataRow row = table.NewRow();
// Alle Felder im Recordset durchlaufen
foreach (ADODB.Field field in rs.Fields)
{
// Feldwert übernehmen
row[field.Name] = field.Value;
}
// DataRow zur Tabelle hinzufügen
table.Rows.Add(row);
}
/// <summary>
/// Fügt einen im Recordset geänderten Datensatz einer DataTable zu.
/// </summary>
/// <param name="table">Ziel-DataTable</param>
/// <param name="rs">Quell-RecordSet</param>
private static void ImportModifiedRow(DataTable table, ADODB.Recordset rs)
{
// Neue DataTable-Zeile erzeugen
DataRow row = table.NewRow();
// Alle Felder im Recordset durchlaufen
foreach (ADODB.Field field in rs.Fields)
{
// Original Feldwert übernehmen
row[field.Name] = field.OriginalValue;
}
// Datensatz an DataTable anfügen
table.Rows.Add(row);
// Status neutralisieren
row.AcceptChanges();
// Alle Felder im Recordset durchlaufen
foreach (ADODB.Field field in rs.Fields)
{
// Feldwert übernehmen
row[field.Name] = field.Value;
}
}
/// <summary>
/// Fügt einen im Recordset ungeänderten Datensatz einer DataTable zu.
/// </summary>
/// <param name="table">Ziel-DataTable</param>
/// <param name="rs">Quell-RecordSet</param>
private static void ImportUnchangedRow(DataTable table, ADODB.Recordset rs)
{
// Neue DataTable-Zeile erzeugen
DataRow row = table.NewRow();
// Alle Felder im Recordset durchlaufen
foreach (ADODB.Field field in rs.Fields)
{
// Feldwert übernehmen
row[field.Name] = field.Value;
}
// Datensatz an DataTable anfügen
table.Rows.Add(row);
// Änderungen akzeptieren
row.AcceptChanges();
}
/// <summary>
/// Fügt einen im Recordset gelöschten Datensatz einer DataTable zu.
/// </summary>
/// <param name="table">Ziel-DataTable</param>
/// <param name="rs">Quell-RecordSet</param>
private static void ImportDeletedRow(DataTable table, ADODB.Recordset rs)
{
// Neue DataTable-Zeile erzeugen
DataRow row = table.NewRow();
// Alle Felder im Recordset durchlaufen
foreach (ADODB.Field field in rs.Fields)
{
// Original Feldwert übernehmen
row[field.Name] = field.OriginalValue;
}
// Datensatz an DataTable anfügen
table.Rows.Add(row);
// Status neutralisieren
row.AcceptChanges();
// Datensatz zum löschen markieren
row.Delete();
}
/// <summary>
/// Erzeugt ein DataTable-Skelett aus einem Recordset.
/// </summary>
/// <param name="rs">Recordset</param>
/// <returns>DataTable-Skelett (Ohne Daten)</returns>
public static DataTable CreateDataTableSkeletonFromRecordset(ADODB.Recordset rs)
{
// DataTable erzeugen
DataTable table = new DataTable();
// Liste für Primärschlüsselspalten erzeugen
List<DataColumn> primaryKeys = new List<DataColumn>();
// Tabellenname übernehmen
table.TableName = rs.Fields[0].Properties["BASETABLENAME"].ToString();
// Zum ersten Datensatz des Recordsets springen
if (!rs.EOF) rs.MoveFirst();
// Alle Felder des Recordsets durchlaufen
foreach (ADODB.Field field in rs.Fields)
{
// DataTable-Spalte erzeugen
DataColumn column = new DataColumn(field.Name, GetCLRTypeFromADODBField(field));
table.Columns.Add(column);
// Wenn das aktuelle Feld ein Primärschlüsselfeld ist ...
if (Convert.ToBoolean(field.Properties["KEYCOLUMN"].Value) == true)
{
// Als Primärschlüsselspalte merken
primaryKeys.Add(column);
}
}
// Primärschlüsselspalten der DataTable festlegen
table.PrimaryKey = primaryKeys.ToArray();
// DataTable zurückgeben
return table;
}
/// <summary>
/// Gibt den CLR-Typ eines bestimmten ADODB-Feldes zurück.
/// </summary>
/// <param name="field">ADODB-Feld aus einem Recordset</param>
/// <returns>CLR-Typ</returns>
public static System.Type GetCLRTypeFromADODBField(ADODB.Field field)
{
// ADODB-Datentyp auswerten
switch (field.Type)
{
case ADODB.DataTypeEnum.adGUID: // Eindeutiger Bezeichner
return typeof(System.Guid);
case ADODB.DataTypeEnum.adBoolean: // Boolean
return typeof(System.Boolean);
case ADODB.DataTypeEnum.adUnsignedTinyInt: // Byte
return typeof(System.Byte);
case ADODB.DataTypeEnum.adChar: // Char
return typeof(System.Char);
case ADODB.DataTypeEnum.adDate: // DateTime
return typeof(System.DateTime);
case ADODB.DataTypeEnum.adDecimal: // Decimal
return typeof(System.Decimal);
case ADODB.DataTypeEnum.adDouble: // Double
return typeof(System.Double);
case ADODB.DataTypeEnum.adSmallInt: // Int16
return typeof(System.Int16);
case ADODB.DataTypeEnum.adInteger: // Int32
return typeof(System.Int32);
case ADODB.DataTypeEnum.adBigInt: // Int64
return typeof(System.Int64);
case ADODB.DataTypeEnum.adTinyInt: // SByte
return typeof(System.SByte);
case ADODB.DataTypeEnum.adSingle: // Single
return typeof(System.Single);
case ADODB.DataTypeEnum.adLongVarChar: // String
return typeof(System.String);
case ADODB.DataTypeEnum.adVarChar: // String
return typeof(System.String);
case ADODB.DataTypeEnum.adLongVarWChar: // String
return typeof(System.String);
case ADODB.DataTypeEnum.adVarWChar: // String
return typeof(System.String);
case ADODB.DataTypeEnum.adUnsignedSmallInt: // UInt16
return typeof(System.UInt16);
case ADODB.DataTypeEnum.adUnsignedInt: // UInt32
return typeof(System.UInt32);
case ADODB.DataTypeEnum.adUnsignedBigInt: // UInt64
return typeof(System.UInt64);
}
// Undefinierten Typ zurückgeben
return typeof(System.String);
}
}
|