Viele bestehende Projekte sind auf Visual Basic 6 oder Office VBA entwickelt. Datenzugriff wird dabei meistens mit Classic ADO (Microsoft ActiveX Data Objects) gemacht.
.NET DLLs lassen sich zwar auch via COM-Interop von VB6 & Co. aufrufen, aber bei der Übergabe von Daten die über int, double und string hinaus gehen, hört der Spass auf.
Abfrageergebnisse aus einer Datenbank z.B. liegen auf der .NET Seite in DataSets/DataTables vor. Damit können die alten Anwendungen aber überhaupt nichts anfangen. Also muss aus der modernen ADO.NET DataTable schnell ein gutes altes ADODB.Recordset werden.
Genau das macht das folgende Snippet. Natürlich auch wieder rückwärts.
Das Ganze ist als Klasse mit ausschließlich statischen Membern realisiert. Einzige Voraussetzung ist ein COM-Verweis auf "Microsoft ActiveX Data Objects 2.8".
/// <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);
}
}
Kommentare zum Snippet