Feedback

C# - ADO-Recordset Converter

Veröffentlicht von am 03.05.2007
(2 Bewertungen)
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".
GFU-Schulungen  [Anzeige]

ASP.NET 2.0 und 3.5

Dieser Kurs vermittelt Ihnen alle Erweiterungen von Microsoft ASP.NET 2.0. Zu diesen zählen u. a. Data Bindung, Master Pages, und Security.

C# 2017/2015/2013 Aufbau

In dieser Schulung lernen Sie fortgeschrittene Techniken im Bereich .Net C#. Dabei stehen neben den eigentlichen Techniken auch architektonische Aspekte im Mittelpunkt.

    /// <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

 

Logge dich ein, um hier zu kommentieren!