<\/p>\n
Sie kennen sicherlich die Funktion aus dem Office-Ppaket, die Ihnen immer die letzten verwendeten Dokumente im Menü anbietet. Diese Funktionalität hat den charmanten Vorteil, dass Sie diese Dateien nicht in der Verzeichnisstruktur Ihrer Festplatte suchen müssen, sondern direkt darauf zugreifen können. Dieses Prinzip namens Most Recent Used (MRU) soll im nachfolgenden Programmierbeispiel für Kundendaten verwendet werden.<\/b><\/p>\n
Das Fallbeispiel<\/p>\n
In der Beispieldatenbank MRU2000.mdb <\/b>finden Sie alle in diesem Artikel beschriebenen Objekte und Codierungen. Öffnen Sie in der Beispieldatenbank das Formular frmStammdaten<\/b>, über das Sie Firmendaten verwalten können (siehe Bild 1). Links von den eigentlichen Daten befindet sich ein Listenfeld, in dem alle Datensätze angezeigt werden, die über Suchen <\/b>ermittelt wurden oder an deren Stammdaten änderungen vorgenommen worden sind.<\/p>\n
![\"missing](\"..\/fileadmin\/_temp_\/2008_02\/MRU-web-images\/Bild284_opt.jpeg\")
<\/p>\n
Bild 1: Verwaltungsformular für Unternehmensdaten<\/span><\/b><\/p>\n Geben Sie in das Textfeld Suchen <\/b>einen beliebigen Suchbegriff für ein Unternehmen ein. Als Platzhalter für eine beliebige Zeichenkette kann das Sternchen (*) verwendet werden. Sobald Sie den zu suchenden Begriff eingegeben haben, bestätigen Sie den Eintrag mit der Eingabetaste und anschließend öffnet sich ein Dialog, in dem alle dem Suchmuster entsprechenden Unternehmen angezeigt werden (siehe Bild 2). Um zum gewünschten Datensatz zu navigieren, klicken Sie entweder doppelt auf den Namen im Listenfeld oder Sie markieren den Datensatz und bestätigen anschließend Ihre Auswahl mit Auswählen<\/b>. Sobald der Dialog geschlossen wird und das aufrufende Formular zum ausgewählten Datensatz navigiert, erscheint der von Ihnen ausgewählte Datensatz in der Liste der zuletzt verwendeten Datensätze und Sie müssen nun nicht mehr mühsam über den Suchdialog zu diesem Datensatz navigieren.<\/p>\n Bild 2: Dem Suchkriterium entsprechende Datensätze<\/span><\/b><\/p>\n Eine weitere Möglichkeit der Übernahme eines Datensatzes in die MRU <\/b>besteht darin, einen existierenden Datensatz zu ändern. Sobald die änderungen an einem Datensatz gespeichert wurden, wird dieser Datensatz ebenfalls in die MRU <\/b>übernommen.<\/p>\n Technische Umsetzung<\/b><\/p>\n Um eine MRU zu programmieren, bedarf es nicht viel Aufwands. Auf Basis der Datenstruktur benötigen Sie zwei Tabellen zur Steuerung der MRU.<\/p>\n tblMRU<\/b><\/p>\n Die wichtigste Tabelle für die Speicherung der letzten Datensätze ist die Tabelle tblMRU<\/b>. Ihre Aufgabe ist es, den Primärschlüssel der Unternehmensdaten nebst Datum des Eintrags zu speichern (s. Tab. 1).<\/p>\n Feld<\/p>\n<\/td>\n Beschreibung<\/p>\n<\/td>\n<\/tr>\n<\/thead>\n Tab. 1: Aufbau der Tabelle tblMRU<\/span><\/b><\/p>\n Sobald ein neuer Eintrag in der Tabelle vorgenommen wird, wird das Datum automatisch durch Access hinzugefügt.<\/p>\n tblMRUParameter<\/b><\/p>\n Die Tabelle tblMRUParameter <\/b>dient der Verwaltung der Steuerungsvariablen für die Verwaltung der MRU. Auch diese Tabelle (s. Tab. 2) hat einen recht simplen Aufbau und speichert ausschließlich einen Parameternamen sowie einen Parameterwert.<\/p>\n Feld<\/p>\n<\/td>\n Beschreibung<\/p>\n<\/td>\n<\/tr>\n<\/thead>\n Tab. 2: Aufbau der Tabelle tblMRUParameter<\/span><\/b><\/p>\n Für das obige Beispiel benötigen Sie nur einen einzigen Parameter, der steuert, wie viele Einträge maximal in der MRU gespeichert werden sollen. Dazu dient der Parameter MAX_ENTRIES<\/b>, der aktuell auf den Wert 25 <\/b>festgelegt ist.<\/p>\n Es wäre auch möglich, ein Verfallsdatum zu verwenden, indem man die Tage angibt, nach denen ein Eintrag automatisch aus der MRU entfernt werden soll. <\/p>\n Eine Klasse für die Kapselung der Funktion<\/b><\/p>\n Die Funktionen der MRU sind in einer Klasse gekapselt, was so eine einfachere Verwaltung und Weiterentwicklung ermöglicht.<\/p>\n Die erste Grundüberlegung für die Funktion ist natürlich der Leistungsumfang. Sie müssen zunächst festlegen, was die Klasse alles leisten soll. Grundsätzlich müssen die Funktionen aus Tab. 3 erfüllt sein.<\/p>\n Funktionalität<\/p>\n<\/td>\n Funktion<\/p>\n<\/td>\n<\/tr>\n<\/thead>\n Tab. 3: Basisfunktionalität der MRU<\/span><\/b><\/p>\n Neben den oben aufgeführten öffentlich zugänglichen Methoden der Klasse werden natürlich auch Hilfsfunktionen benötigt, die Grundfunktionen der Klasse steuern (s. Tab. 4).<\/p>\n Funktionalität<\/p>\n<\/td>\n Funktion<\/p>\n<\/td>\n<\/tr>\n<\/thead>\n Tab. 4: Hilfsfunktionen der MRU<\/span><\/b><\/p>\n Aufbau der Klasse clsMRU<\/b><\/p>\n Die oben beschriebene Funktionalität ist in der Klasse clsMRU <\/b>programmiert. Sie befindet sich in der Beispieldatenbank und kann durch einen Doppelklick im Visual Basis Editor angezeigt und bearbeitet werden.<\/p>\n Für die korrekte Arbeitsweise der Klasse werden Parameter eingesetzt. Damit diese Parameter nicht in jeder Funktion erneut abgerufen werden, speichert die Klasse die Parameterwerte in lokalen Variablen und Konstanten, die während des gesamten Lebenszyklus der Klasse zur Verfügung stehen. Es bietet sich also an, die Parameter für den Gebrauch gleich bei der Initialisierung der Datenklasse auszulesen und zu speichern.<\/p>\n Um Code gleich bei der Initialisierung einer Klasse ausführen zu lassen, verwenden Sie das Ereignis Initialize <\/b>des Klassenobjektes. Es wird automatisch ausgeführt, sobald Sie auf Methoden und Eigenschaften einer Klasse zum ersten Mal zugreifen. In diesem Beispiel ist die Initialisierung nicht sehr aufwändig, da lediglich die lokale Variable lngNumOfEntries <\/b>gefüllt wird. Sie speichert den Wert der maximal zu speichernden Einträge in die MRU:<\/p>\n Der Wert der Variablen wird durch die Funktion GetParameterValue <\/b>gesetzt. Diese Funktion liest aus der Tabelle tblMRUParameter <\/b>den Wert zum entsprechenden Parameterdatensatz aus.<\/p>\n <\/p>\n Da diese Funktion lediglich innerhalb der Klasse benötigt wird, ist sie als Private <\/b>deklariert und somit nach außen nicht sichtbar. Der Zugriff auf die Datenstrukturen der Tabellen erfolgt über ADO und OLEDB, aber selbstverständlich können Sie auch mittels DAO die gleiche Funktionalität erreichen. Das Ergebnis der Abfrage wird in einem ADO-RecordSet rst <\/b>gespeichert und kann anschließend für die weitere Bearbeitung verwendet werden.<\/p>\n Sollte kein Eintrag gefunden werden, erhalten Sie einen NULL-Wert.<\/p>\n Variablen oder Properties<\/b><\/p>\n Wenn Sie sich die Klasse clsMRU <\/b>etwas genauer anschauen, werden Sie bemerken, dass es in dieser Klasse zwei Properties (TableName <\/b>und PrimaryKey<\/b>) gibt. Mithilfe von Properties (Klasseneigenschaften) können Sie außerhalb der Klasse Werte für den Gebrauch der Klasse setzen. Sie können aber auch mithilfe von Properties Werte aus einer Klasse auslesen. Beides ist nur dann möglich, wenn Sie eine öffentliche Property<\/b>-Eigenschaft deklarieren.<\/p>\n „Warum denn eine Property Eine Variable innerhalb einer Klasse, die als Public <\/b>deklariert wird, erfüllt doch die gleiche Funktion.“ Das stimmt vollkommen, jedoch haben Variablen eine kleine Einschränkung – Sie können einer Variablen einen Wert zuweisen oder einen Wert abrufen. Sie haben dann jedoch keine Möglichkeit, innerhalb der Klasse etwa die Plausibilität der Zuweisung zu prüfen. Genau das aber ist der große Vorteil von Properties, weil sie gleichzeitig Prozeduren sind. Um einer Property einen Wert zuzuweisen, verwenden Sie das Schlüsselwort Let, <\/b>und um den Wert einer Eigenschaft abzurufen, das Schlüsselwort Get<\/b>.<\/p>\n Als Beispiel für die Vorteile von Eigenschaften soll die Eigenschaft Tablename <\/b>dienen. Der Code für die Zuweisung eines Wertes durch Property Let <\/b>wird hierzu ein wenig genauer unter die Lupe genommen. Wenn der Anwender einen Tabellennamen für die Klasse bestimmt, soll der Wert nicht einfach übernommen werden, sondern es soll überprüft werden, ob das Objekt auch tatsächlich in der Datenbank enthalten ist.<\/p>\n Innerhalb einer For…Next<\/b>-Schleife werden die Tabellenobjekte in Ihrer Anwendung überprüft. Sollte eine Tabelle mit dem von Ihnen angegebenen Namen existieren, wird die Variable strTableName <\/b>gesetzt und die Schleife wird verlassen.<\/p>\n AddEntry<\/b><\/p>\n Um der MRU einen Eintrag hinzuzufügen, verwenden Sie die Methode AddEntry<\/b>. Die Methode AddEntry <\/b>benötigt als Übergabeparameter die eindeutige Kennung des Datensatzes (Sid<\/b>) und versucht, diesen Datensatz in die Tabelle tblMRU <\/b>einzutragen. Sollte der Eintrag fehlschlagen, weil ein entsprechender Eintrag bereits vorhanden ist, wird die Methode ohne Fehlermeldung verlassen.<\/p>\n Ansonsten liefert die Methode als Rückgabewert den Erfolg des Eintrags in Form eines Bool“schen Werts (True<\/b>\/False<\/b>). Die Methode AddEntry <\/b>arbeitet ebenfalls mit ADO und verwendet als Befehlsanweisung eine Konstante, die den SQL-Befehl beinhaltet. Die Befehlsfolge finden Sie in der Konstanten SQL_MRU_ADDENTRY<\/b>.<\/p>\n Eine besondere Fehlerbehandlung findet im Error-Handler statt. Sollte der von Ihnen gewünschte Eintrag bereits in der MRU enthalten sein, wird beim Einfügen eines Datensatzes eine Schlüsselverletzung ausgelöst. Diese Schlüsselverletzung (ADO-ErrorCode: -2147467259) wird über die vordefinierte Konstante MRU_ERR_ENTRYEXISTS <\/b>abgefangen und es wird mit UpdateEntry <\/b>darauf reagiert. Die Methode UpdateEntry <\/b>ist privat und somit von außen nicht sichtbar. Sie als Anwender müssen lediglich AddEntry <\/b>ausführen und sich nicht mehr darum kümmern, ob ein Eintrag bereits existiert!<\/p>\n DeleteEntry<\/b><\/p>\n So, wie Einträge der MRU hinzugefügt werden, müssen solche Einträge auch wieder aus der Liste herausgelöscht werden. Dazu verwenden Sie die Methode DeleteEntry<\/b>. Die Methode DeleteEntry <\/b>besitzt den gleichen Aufbau und die gleiche Funktionsweise wie die Methode AddEntry<\/b>. Lediglich der SQL-Befehl für das Löschen eines Eintrags unterscheidet sich von dem der Methode AddEntry<\/b>. Der SQL-Befehl für das Löschen von Datensätzen aus der MRU befindet sich in der Konstanten SQL_MRU_DELETEENTRY<\/b>.<\/p>\n Reorganisation von veralteten Einträgen<\/b><\/p>\n Durch den Parameter MAX_ENTRIES <\/b>legen Sie fest, wie viele Einträge maximal in der MRU gespeichert werden sollen. Sobald ein neuer Eintrag hinzugefügt oder ein bestehender Eintrag aktualisiert wird, wird automatisch eine Reorganisation des Datenbestandes vorgenommen. Diese Aufgabe wird von der Methode fn_app_ReorgMRUList <\/b>übernommen. Damit diese Methode nach außen nicht sichtbar ist, wird sie als Private<\/b> deklariert (in einer Zeile): <\/p>\n Erwähnenswert bei dieser Funktion ist der auszuführende SQL-Befehl. Da nur eine begrenzte Anzahl von Datensätzen in der MRU verbleiben soll, muss sichergestellt sein, dass immer die aktuellsten Datensätze in der Ergebnismenge verbleiben. Eine solche Lösung ist nur mittels Unterabfrage möglich. Schauen wir uns zunächst einmal den kompletten SQL-Befehl an, wie er in der Konstanten SQL_MRU_REORG <\/b>hinterlegt ist:<\/p>\n Wie Sie gut erkennen können, bewirkt die Unterabfrage, die sich in den Klammern befindet, eine Filterung von Datensätzen, die nach dem Datum sortiert werden. Wenn also der Parameter MAX_ENTRIES <\/b>auf 25 <\/b>festgelegt ist, ergibt das Ergebnis der Unterabfrage immer die 25 aktuellsten Datensätze aus der Tabelle tblMRU<\/b>. Die eigentliche Aktionsabfrage (DELETE * FROM tblMRU<\/b>) löscht also alle Datensätze, die nicht der Ergebnismenge der Unterabfrage entsprechen.<\/p>\n Beachten Sie bei dem SQL-Befehl, dass hier keine Parameter verwendet werden. Auch ist die TOP<\/b>-Anweisung nicht mit einem Parameter initialisierbar. Parameter können nur in den Filterklauseln verwendet werden.<\/p>\n Anwendung der Klasse clsMRU<\/b><\/p>\n Die Programmierung der Klasse ist die aufwändigste Arbeit. Nachdem die Klasse mit ihren Basismethoden erstellt wurde, kann sie nun zum Einsatz kommen. Zur Demonstration der verschiedenen Funktionen der Klasse dient das Formular frmStammdaten<\/b>.<\/p>\n Hinzufügen von MRU-Einträgen bei änderung eines Datensatzes<\/b><\/p>\n Wenn Sie die Daten eines Stammsatzes verändern, wird der Stammsatz automatisch der MRU hinzugefügt.<\/p>\n Um den Datensatz der MRU hinzuzufügen, verwenden Sie am besten das Ereignis After Update <\/b>des Formulars. Damit stellen Sie sicher, dass der Eintrag erst nach der erfolgreichen Speicherung der Daten zur MRU hinzugefügt wird.<\/p>\n Zunächst erstellen Sie eine neue Instanz der Klasse clsMRU<\/b>. Erst, wenn Sie das Klassenobjekt erstellt haben, können Sie auf die Methoden und Eigenschaften der Klasse zugreifen.<\/p>\n Damit die Methode AddEntry <\/b>verwendet werden kann, müssen die Eigenschaften für Tabellenname und Primärschlüssel bestimmt werden. Dies geschieht durch Zuweisung dieser Werte an die Eigenschaften TableName <\/b>und PrimaryKey<\/b>.<\/p>\n Anschließend wird die Methode AddEntry <\/b>verwendet, um den Datensatz der MRU hinzuzufügen. Wenn der Datensatz erfolgreich eingefügt worden ist, wird das in dem Formular befindliche MRU-Listenfeld aktualisiert. Als Datengrundlage für das Listenfeld dient die Abfrage view_app_MRUList<\/b>.<\/p>\n Hinzufügen von MRU-Einträgen nach erfolgreicher Suche nach Stammdaten<\/b><\/p>\n Eine weitere Möglichkeit, Stammdaten der MRU hinzuzufügen, besteht beim Suchen nach Datensätzen. Im Beispielformular befindet sich über den Stammdaten ein ungebundenes Textfeld, in das Sie beliebige Suchmuster eingeben können, um nach Stammdaten zu suchen.<\/p>\n Das Ergebnis der Suche wird mithilfe des Formulars frmSearchRecord <\/b>abgebildet. Sobald ein Datensatz aus dem Ergebnis ausgewählt wird, wird er automatisch der MRU hinzugefügt.<\/p>\n Aus Gründen der Benutzerfreundlichkeit gibt es im Formular zwei unterschiedliche Möglichkeiten, wie Sie eine Auswahl treffen können.<\/p>\n Entweder wählen Sie einen Datensatz aus dem Listenfeld aus und klicken anschließend auf die Befehlsschaltfläche Auswählen<\/b> oder aber Sie klicken doppelt auf den gewünschten Eintrag im Listenfeld. <\/p>\n Da beide Aktionen – Doppelklicken in die Ergebnisliste oder Klick auf den Auswahl-Button – das gleiche Ergebnis bewirken, kapseln Sie die Funktionalität einfach in einer Prozedur, die Sie bei den einzelnen Ereignissen in den Code implementieren. Die Prozedur ein Bestandteil des Formulars.<\/p>\n Die Prozedur fn_app_SelectRecord <\/b>erwartet als Übergabeparameter die eindeutige Kennzeichnung für den Datensatz.<\/p>\n Mithilfe dieser Kennzeichnung wird zunächst versucht, in der Datenquelle, die dem Hauptformular zugrunde liegt, den Datensatz zu finden, dem die eindeutige Kennzeichnung zugeordnet ist. Wenn ein solcher Datensatz in den Formulardaten gefunden wird, wird die Klasse clsMRU <\/b>initialisiert und der Datenschlüssel wird mit der Methode AddEntry <\/b>der MRU hinzugefügt.<\/p>\n Die Prozedur wird in den folgenden Objekten im Formular aufgerufen (s. Tab. 5).<\/p>\n Objekt<\/p>\n<\/td>\n Ereignis<\/p>\n<\/td>\n<\/tr>\n<\/thead>\n Tab. 5: Objekte und Ereignisse für die Speicherung der MRU<\/span><\/b><\/p>\n Neben dem Hinzufügen von Daten zur MRU müssen Sie natürlich auch berücksichtigen, dass ein Benutzer einen Datensatz aus den Stammdaten wieder löscht. Hierbei ist zu beachten, dass dieser Stammsatz auch in der MRU steht. Zu diesem Zweck finden Sie im Hauptformular frmStammdaten <\/b>eine Befehlsschaltfläche mit dem Namen cmdDeleteRecord<\/b>. <\/p>\n Das Click<\/b>-Ereignis dieses Objektes besitzt den nachfolgenden Code, der im Einzelnen beschrieben ist.<\/p>\n Zunächst wird der Datensatz mittels des Command<\/b>-Objekts von ADO gelöscht. Die Vorgehensweise für die Verwendung von Parametern wurde bereits im Vorfeld erläutert.<\/p>\n Sobald der Datensatz gelöscht wurde, wird das Formular aktualisiert und die Klasse clsMRU <\/b>initialisiert.<\/p>\n Um einen eventuell bestehenden Datensatz aus der MRU zu löschen, wird die Methode DeleteEntry <\/b>aufgerufen. Als Parameter erhält sie die eindeutige Kennzeichnung des zuvor gelöschten Datensatzes.<\/p>\n War der Löschvorgang erfolgreich, wird die Liste mit den zuletzt benutzten Datensätzen aktualisiert und die Prozedur wird verlassen.<\/p>\n Zusammenfassung<\/b><\/p>\n Wie Sie anhand des relativ einfachen Beispiels gesehen haben, müssen Sie nicht viel Arbeit investieren, um Ihren Kollegen und\/oder Kunden eine komfortable Navigationsmöglichkeit an die Hand zu geben, mit der sie leichter auf immer wieder verwendete Datensätze zugreifen können.<\/p>\n Das obige Beispiel hat ebenfalls gezeigt, dass es Sinn macht, Funktionen in Themen zusammenzufassen und in Klassen zu kapseln. Sie können die Klasse clsMRU <\/b>mit wenigen Handgriffen Ihren eigenen Bedürfnissen anpassen. Sie müssen lediglich die Datengrundlage sowie die SQL-Befehle entsprechend ihren Tabellennamen und Schlüsselfeldern anpassen. Achten Sie außerdem darauf, dass Sie den Datentyp für die Parameter ändern müssen, wenn ihre Schlüsselfelder nicht numerisch sind.<\/p>\n Enthaltene Beispieldateien:<\/p>\n MRU2000.mdb<\/p>\n![\"missing](\"..\/fileadmin\/_temp_\/2008_02\/MRU-web-images\/Bild297_opt.jpeg\")
<\/p>\n\n\n
\n \n\n \n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n \n\n
\n \n\n \n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n \n\n
\n \n\n \n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n \n\n
\n \n\n \n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Private Sub Class_Initialize()\r\n lngNumOfEntries = _\r\n GetParameterValue("MAX_ENTRIES")\r\n End Sub<\/pre>\nPrivate Function GetParameterValue(strParameter _\r\n As String) As Variant\r\n ...\r\n Set cmd = New ADODB.Command\r\n With cmd\r\n Set .ActiveConnection = _\r\n CurrentProject.Connection\r\n .CommandText = SQL_MRU_PARAMETER\r\n .CommandType = adCmdText\r\n Set prm = .CreateParameter("Parameter", _\r\n adVarChar, adParamInput, _\r\n Len(strParameter) + 1, strParameter)\r\n .Parameters.Append prm\r\n Set rst = .Execute()\r\n End With\r\n If Not rst Is Nothing Then\r\n If Not rst.EOF And rst.BOF Then\r\n GetParameterValue = _\r\n rst.Fields(0).Value\r\n End If\r\n End If\r\n ...\r\nEnd Function<\/pre>\nIf Not rst Is Nothing Then\r\n If Not rst.EOF And rst.BOF Then\r\n GetParameterValue = rst.Fields(0).Value\r\n End If\r\nEnd If<\/pre>\n
Public Property Let TableName(TName As String)\r\nOn Error GoTo ErrorHandler\r\nFor Each tdef In DBEngine(0)(0).TableDefs\r\n If tdef.Name = TName Then\r\n strTableName = TName\r\n Exit For\r\nEnd If\r\nNext tdef\r\nExitCode:\r\nOn Error Resume Next\r\nSet tdef = Nothing\r\nExit Property\r\nErrorHandler:\r\nMsgBox "Die Tabelle " & TName _\r\n& " ist nicht in der Datenbank " _\r\n& "enthalten", vbInformation\r\nResume ExitCode\r\nEnd Property<\/pre>\n
Public Function AddEntry(SId As Long) As Boolean\r\nOn Error GoTo ErrorHandler\r\nIf lngNumOfEntries > 0 Then\r\n Call fn_app_ReorgMRUList(lngNumOfEntries)\r\nEnd If\r\nSet cmd = New ADODB.Command\r\nWith cmd\r\nSet .ActiveConnection = _\r\nCurrentProject.Connection\r\n.CommandText = SQL_MRU_ADDENTRY\r\n.CommandType = adCmdText\r\nSet prm = .CreateParameter("TableName", _\r\nadVarChar, adParamInput, _\r\nLen(strTableName) + 1, strTableName)\r\n.Parameters.Append prm\r\nSet prm = .CreateParameter( _\r\n"PrimaryKey", adVarChar, _\r\nadParamInput, _\r\nLen(strPrimaryKey) + 1, _\r\nstrPrimaryKey)\r\n.Parameters.Append prm\r\nSet prm = .CreateParameter("SId", _\r\nadInteger, adParamInput, , SId)\r\n.Parameters.Append prm\r\n.Execute\r\nEnd With\r\nAddEntry = True\r\nExitCode:\r\nOn Error Resume Next\r\nSet prm = Nothing\r\nSet cmd = Nothing\r\nExit Function\r\nErrorHandler:\r\nSelect Case Err.Number\r\nCase MRU_ERR_ENTRYEXISTS\r\nAddEntry = UpdateEntry(SId)\r\nResume ExitCode\r\nCase Else: MsgBox Err.Description, _\r\nvbInformation, "Fehler in MRU: " _\r\n& CStr(Err.Number)\r\nEnd Select\r\nResume ExitCode\r\nEnd Function<\/pre>\nPrivate Function fn_app_ReorgMRUList(NumOfEntries As Long)<\/pre>\n
DELETE * FROM tblMRU WHERE SId NOT IN (SELECT TOP $Number SId FROM tblMRU ORDER BY InsertDate DESC).<\/pre>\n
Private Sub Form_AfterUpdate()\r\n ...\r\n Dim m As New clsMRU\r\n Dim blnResult As Boolean\r\n With m\r\n .TableName = "tblStammdaten"\r\n .PrimaryKey = "SId"\r\n blnResult = .AddEntry(Me!SId)\r\n If blnResult = True Then\r\n Me!lstMRU.Requery\r\n End If\r\n End With\r\n ...\r\n End Sub<\/pre>\n
Private Sub fn_app_SelectRecord(SId As Long)\r\n On Error GoTo ErrorHandler\r\n Dim frm As Form\r\n Dim rst As DAO.Recordset\r\n Set frm = Forms("frmStammdaten")\r\n Set rst = frm.RecordsetClone\r\n rst.FindFirst "SId = " & SId\r\n If rst.NoMatch = False Then\r\n Set m = New clsMRU\r\n With m\r\n .TableName = "tblStammdaten"\r\n .PrimaryKey = "SId"\r\n blnResult = .AddEntry(SId)\r\n If blnResult = True Then\r\n frm!lstMRU.Requery\r\n End If\r\n End With\r\n frm.Bookmark = rst.Bookmark\r\n End If\r\n ...\r\n DoCmd.Close acForm, Me.Name\r\n ...\r\n End Sub<\/pre>\n\n\n
\n \n\n \n \n \n<\/td>\n \n<\/td>\n<\/tr>\n \n \n<\/td>\n \n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Private Sub cmdDeleteRecord_Click()\r\n On Error GoTo ErrorHandler\r\n Dim lngSId As Long\r\n Dim blnReturnValue As Boolean\r\n With Me\r\n lngSId = Nz(!SId, 0)\r\n If lngSId = 0 Then GoTo ExitCode\r\n End With\r\n Set cmd = New ADODB.Command\r\n With cmd\r\n Set .ActiveConnection = _\r\n CurrentProject.Connection\r\n .CommandText = SQL_DELETE_RECORD\r\n .CommandType = adCmdText\r\n Set prm = .CreateParameter("Sid", _\r\n adInteger, adParamInput, , lngSId)\r\n .Parameters.Append prm\r\n .Execute\r\n Me.Requery\r\n End With\r\n Set m = New clsMRU\r\n blnReturnValue = m.DeleteEntry(lngSId)\r\n If blnReturnValue = True Then\r\n Me!lstMRU.Requery\r\n End If\r\n ...\r\n End Sub<\/pre>\nDownloads zu diesem Beitrag<\/h3>\n