{"id":55000327,"date":"2006-02-01T00:00:00","date_gmt":"2020-05-06T15:18:15","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=327"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"PerformanceTester_als_AccessAddIn","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/","title":{"rendered":"Performance-Tester als Access-Add-In"},"content":{"rendered":"

\"\"<\/p>\n

Zusammenfassung<\/h3>\n

Erstellen Sie ein Add-In zum Messen und Vergleichen der Performance von Funktionen.<\/p>\n

Techniken<\/h3>\n

Formuare, Add-Ins, VBA, Klassen<\/p>\n

Voraussetzungen<\/h3>\n

Access 2000 und höher<\/p>\n

Beispieldateien<\/h3>\n

Beispieldatenbank.mdbPerformance.mda<\/a><\/p>\n

<\/h3>\n

André Minhorst, Duisburg<\/b><\/p>\n

Die Performance einer Datenbankanwendung ist mithin ein entscheidender Faktor für die Akzeptanz beim Benutzer. Muss dieser bei bestimmten Aktionen länger als ein paar Sekunden auf die Anwendung warten, stellt sich schnell Unzufriedenheit ein. Nun dreht es sich in diesem Beitrag nicht um die Optimierung der Performance, sondern um die Messung der Resultate von Performance-Optimierungen. Und dabei erfahren Sie, wie Sie sich ein nützliches Add-In zur Messung der Performance bauen.<\/b><\/p>\n

Die Performance einer Anwendung hängt in der Regel von vielen kleinen Faktoren und Bereichen ab, die man getrennt optimiert und entsprechend messen möchte. Für die Messung wird normalerweise die Zeit ermittelt, die die Anwendung für die Erledigung einer bestimmten Aufgabe benötigt.<\/p>\n

Das ist auch bei dem Add-In der Fall, das Sie in diesem Beitrag kennen lernen: Es erwartet die Angabe zweier Funktionen mit der gleichen Aufgabe und ermittelt die von den Funktionen benötigte Zeit.<\/p>\n

Zeit messen per API<\/h3>\n

Unter VBA gibt es verschiedene, unterschiedlich genaue Möglichkeiten zur Zeitmessung. Im hier verwendeten Tool kommen zwei API-Funktion namens QueryPerformanceCounter und QueryPerformanceFrequency zum Zuge, die man folgendermaßen deklariert (jeweils in einer Zeile):<\/p>\n

Declare Function QueryPerformanceCounter Lib \"Kernel32\" (X As Currency) As Long\r\nDeclare Function QueryPerformanceFrequency Lib \"Kernel32\" (Y As _Currency) As Long<\/pre>\n
Die erste Funktion weist der als Parameter angegebenen Variablen den Zählerstand eines Prozessor-Counters zu. Wird dieser durch die mit QueryPerformanceFrequency ermittelte Counter-Frequenz geteilt, so erhält man in einer vom jeweiligen Rechner abhängigen Auflösung die Zeit in Sekunden. Um die Zeit zu messen, die eine Funktion benötigt, speichert man einmal den so ermittelten Wert in einer Currency-Variablen, ruft die Funktion auf und berechnet dann aus der Differenz des aktuellen Wertes und dem gespeicherten Wert die benötigten Sekunden.<\/p>\n
üblicherweise möchte man mit einer Performance-Messung zwei oder mehr verschiedene Varianten einer Funktion vergleichen. Bevor man hier loslegt, sollte man sich zunächst im Klaren darüber sein, wo sich Optimierungen und damit auch Messungen überhaupt lohnen. Es gibt sicher viele Beispiele für kleine Code-Optimierungen, die eine änderung der benötigten Zeit im Bereich von Sekundenbruchteilen bewirken. Hier kann man den Hebel ansetzen, wenn diese Funktionen sehr, sehr oft aufgerufen werden oder wenn man die Anwendung wirklich bis ins Letzte auf Performance tunen möchte.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 1:  Das Performance-Test-Tool im Einsatz<\/span><\/b><\/p>\n
Wer suchet, der findet<\/h3>\n
Zunächst sollten Sie sich jedoch auf die Suche nach den wirklichen Performance-Schluckern machen und diesen auf den Leib rücken. Bei dieser Suche hilft Ihnen das nachfolgend beschriebene Tool nicht. Sie sollen aber dennoch nicht ohne einen Tipp zu diesem Thema weiterlesen: Verwenden Sie doch einfach die QueryPerformanceCounter-Funktion an verschiedenen Stellen der Anwendung, die Ihnen verdächtig vorkommen.<\/p>\n
Schauen Sie zunächst, welche Funktionen viel Zeit kosten, und verfeinern Sie die Suche anschließend, bis Sie optimalerweise die Zeile gefunden haben, die für unerwünscht hohen Zeitverbrauch verantwortlich sind.<\/p>\n
Optimieren mit System<\/h3>\n
Haben Sie eine einzelne oder mehrere zusammenhängende Zeilen gefunden, die für schlechte Performance (mit)verantwortlich sind, haben Sie einen Ansatzpunkt für eine Optimierung. Manchmal lässt sich der Optimierungshebel genau an der gefundenen Stelle ansetzen, manchmal sind aber auch Operationen erforderlich, die sich auf weit größere Teile des Quellcodes beziehen.<\/p>\n
Optimierungen quantitativ bewerten<\/h3>\n
Hier kommt nun endlich das Performance-Test-Tool zum Einsatz. Es sieht wie in Bild 1 aus und lässt sich wie folgt bedienen: Zunächst wählen Sie das Standardmodul oder das Formular aus, in dem sich die zu testende Routine befindet. Nach dem Auswählen des Objekts werden die weiteren Kombinationsfelder mit den im ausgewählten Modul enthaltenen Routinen gefüllt. Ganz wichtig:  Die Routinen müssen als öffentliche Routinen deklariert sein! Sonst hat das Tool keine Möglichkeit, die Routinen aufzurufen.<\/p>\n
Legen Sie nun zunächst fest, wie oft die Funktionen jeweils aufgerufen werden sollen. Das ist sinnvoll, wenn eine Routine sehr schnell abläuft – also beispielsweise schneller als eine Millisekunde -, aber in der eigentlichen Anwendung etwa in einer Schleife viele Male aufgerufen wird. Beginnen Sie einfach mit einer kleinen Zahl wie 1 oder 10 und arbeiten Sie sich dann in größere Dimensionen vor, wenn das Messergebnis nicht befriedigend ist. Anschließend legen Sie die zu vergleichenden Routinen fest. Hierbei ist Folgendes zu beachten:<\/p>\n
  • Die Messung von Routinen in Formular-Modulen ist mit Sub- und Function-Prozeduren möglich.<\/li>\n
  • In Klassenmodulen befindliche Methoden können Sie nicht direkt messen! Eine alternative Möglichkeit finden Sie allerdings weiter unten.<\/li>\n
    Wenn Sie die benötigten Daten eingegeben haben, klicken Sie einfach auf die Schaltfläche Test starten. Das Tool arbeitet die angegebenen Funktionen so oft wie angegeben ab und gibt im Formular die gemessene Zeit sowie die absoluten und relativen Abweichungen von der jeweils anderen Routine aus. Außerdem kennzeichnet es die schnellere und die langsamere Variante mit entsprechenden Symbolen (siehe Bild 1).<\/p>\n
    Wie testet man Methoden aus Klassenmodulen<\/h3>\n
    Auf die Methoden von Klassenmodulen kann das Tool nicht direkt zugreifen. Der Grund ist, dass die Klasse dazu deklariert und instanziert werden müsste, was zwar prinzipiell möglich ist, aber nur, wenn der Name der Klasse zuvor bekannt ist. Das Tool soll aber als Add-In in beliebigen Datenbanken eingesetzt werden; somit müsste es zur Laufzeit zuvor nicht bekannte Klassen instanzieren. Das funktioniert mit VBA leider nicht, daher müssen Sie zur Messung der Performance von in Klassen verborgenen Methoden einen kleinen Umweg gehen.<\/p>\n
    Dazu legen Sie in einem Standardmodul eine öffentliche Function-Routine an, die die gewünschte Klasse deklariert und instanziert und die entsprechende Methode aufruft. Das kann beispielsweise wie in Quellcode 1 aussehen.<\/p>\n
    clsZeitmessungBeispiele ist eine Klasse mit den zwei Methoden EarlyBinding und LateBinding, die in Quellcode 2 abgedruckt sind.<\/p>\n
    Die erste Funktion TestKlasse1 deklariert und instanziert ein Objekt der Klasse clsZeitmessungBeispiele und ruft die Methode EarlyBinding auf, die Funktion TestKlasse2 erledigt selbiges für die Methode LateBinding.<\/p>\n
    Um zu vergleichen, welche der beiden Methoden schneller ist, wählen Sie einfach das Standardmodul mdlZeitmessungBeispiele und die beiden Funktionen TestKlasse1 und Testklasse2 im Performance-Mess-Tool aus und starten den Test. Die absolute Differenz zwischen den gemessenen Zeiten ist sicher aussagekräftig, bezieht sich jedoch auf den kompletten Aufruf inklusive Wrapper-Funktion und der eigentlich zu testenden Methode.<\/p>\n
    Um den relativen Unterschied zwischen den beiden Methoden zu ermitteln, müssen Sie freilich noch einen draufsetzen: Das Tool bietet die Möglichkeit, eine Referenzfunktion anzugeben. Diese Funktion sollte alle Elemente bis auf die eigentlich zu testenden Anweisungen enthalten. <\/p>\n
    Quellcode 1: Aufruf von in Klassen befindlichen Methoden<\/b><\/p>\n
    Public Function TestKlasse1()\r\n    Dim obj As clsZeitmessungBeispiele\r\n    Set obj = New clsZeitmessungBeispiele\r\n    obj.EarlyBinding\r\n    Set obj = Nothing\r\nEnd Function\r\nPublic Function TestKlasse2()\r\n    Dim obj As clsZeitmessungBeispiele\r\n    Set obj = New clsZeitmessungBeispiele\r\n    obj.LateBinding\r\n    Set obj = Nothing\r\nEnd Function\r\nPublic Function TestKlasseReferenz()\r\n    Dim obj As clsZeitmessungBeispiele\r\n    Set obj = New clsZeitmessungBeispiele\r\n    ''obj.LateBinding\r\n    Set obj = Nothing\r\nEnd Function<\/pre>\n
    Quellcode 2: Methoden der Klasse clsZeitmessungBeispiele<\/b><\/p>\n
    Public Sub EarlyBinding()\r\n    Dim cbr As CommandBar\r\n    Dim strName As String\r\n    For Each cbr In Application.CommandBars\r\n        strName = cbr.Name\r\n    Next cbr\r\n    Set cbr = Nothing\r\nEnd Sub\r\nPublic Sub LateBinding()\r\n    Dim strName As String\r\n    Dim cbr As Object\r\n    For Each cbr In Application.CommandBars\r\n        strName = cbr.Name\r\n    Next cbr\r\n    Set cbr = Nothing\r\nEnd Sub\r\n<\/pre>\n
    <\/p>\n
    <\/b><\/p>\n
    Bild 2:  Genaueres Messen der relativen Differenz durch Verwenden einer Referenzfunktion<\/span><\/b><\/p>\n
    <\/p>\n
    <\/p>\n
    <\/b><\/p>\n
    Bild 3:  Einträge des Kombinationsfeldes cboModule<\/span><\/b><\/p>\n
    In Quellcode 1 ist dies die dritte Funktion namens TestKlasseReferenz, die zwar ein Objekt der Klasse clsZeitmessungBeispiele erzeugt, aber keine Methode aufruft. <\/p>\n
    Die Differenz der gemessenen Zeiten für die Funktionen mit den eigentlichen Aufrufen und des Referenzaufrufs liefert so einen wesentlich genaueren Wert für den relativen Unterschied beim Aufrufen der zu testenden Methoden.<\/p>\n
    Bild 2 zeigt, wie der Aufruf und das Messergebnis aussehen könnten. Die vorderen Werte für die erste und die zweite Funktion liefern die um die von der Referenzfunktion benötigten Zeit reduzierten Ergebnisse. <\/p>\n
    Die Zahlen in Klammern sind die Werte ohne Betrachtung der Referenzfunktion.<\/p>\n
    Das Tool beinhaltet ein Formular, ein Standard-  sowie ein Klassenmodul.<\/p>\n
    Das Formular frmPerformance<\/h2>\n
    Das Formular aus Bild 2 ist das einzige sichtbare Objekt dieser Anwendung. Es dient zum Eingeben aller relevanten Daten und zeigt die Ergebnisse der Performance-Messung an.<\/p>\n
    Obwohl das Formular relativ simpel aussieht, steckt in seinen Funktionen einiges an Know-how. Das Ganze beginnt mit dem Füllen der Kombinationsfelder.<\/p>\n
    Auswahl der Module<\/h3>\n
    Das erste Kombinationsfeld cboModule wird beim öffnen des Formulars mit den in der Datenbank enthaltenen Modulen gefüllt. <\/p>\n
    Dafür sorgt die Ereignisprozedur Beim öffnen des Formulars (s. Quellcode 3).<\/p>\n
    Sie weist der Eigenschaft RowSource des Kombinationsfeldes cboModule das Ergebnis der Funktion ModuleEinlesen zu. Diese Funktion liefert eine Zeichenkette mit einer Auflistung der Module und deren Eigenschaften in der Form <Modulname>; <Modultyp-Bezeichnung>; <Modultyp-ID>; <Projektname>; zurück.<\/p>\n
    Ein Beispieleintrag lautet etwa wie folgt:<\/p>\n
    mdlZeitmessungBeispiele;Standardmodul;1;Beispielprojekt;<\/pre>\n
    Damit das Kombinationsfeld die Einträge wie in Bild 3 anzeigt, stellen Sie die Eigenschaften Spaltenanzahl und Spaltenbreiten auf die Werte 4 beziehungsweise 5cm;5cm;0cm;0cm ein.<\/p>\n
    Außerdem wählen Sie für die Eigenschaft Herkunftstyp den Eintrag Wertliste aus.<\/p>\n
    Quellcode 4: Einlesen der Module<\/b><\/p>\n
    Private Function ModuleEinlesen() As String\r\n    Dim i As Integer\r\n    Dim intVBComponentsCount As Integer\r\n    Dim objVBComponent As VBComponent\r\n    Dim strModulename As String\r\n    Dim strModuletype As String\r\n    Dim strModules As String\r\n    Dim objVBProjekt As VBProject\r\n    For Each objVBProjekt In VBE.VBProjects\r\n        If Not objVBProjekt.Name = \"Performance-Tester\" Then\r\n            intVBComponentsCount = objVBProjekt.VBComponents.Count\r\n            For i = 1 To intVBComponentsCount\r\n                Set objVBComponent = objVBProjekt.VBComponents.Item(i)\r\n                strModulename = objVBComponent.Name\r\n                Select Case objVBComponent.Type\r\n                    Case vbext_ct_StdModule\r\n                        strModuletype = \"Standardmodul\"\r\n                    Case vbext_ct_Document\r\n                        strModuletype = \"Formular- oder Berichtsmodul\"\r\n                End Select\r\n                If objVBComponent.Type = 1 Or objVBComponent.Type = 100 Then\r\n                    strModules = strModules & strModulename & \";\" & strModuletype & \";\" _                        & objVBComponent.Type & \";\" & objVBProjekt.Name & \";\"\r\n                End If\r\n            Next i\r\n        End If\r\n    Next objVBProjekt\r\n    ModuleEinlesen = strModules\r\n    Set objVBComponent = Nothing\r\nEnd Function\r\n<\/pre>\n
    Für das eigentliche Einlesen ist die Routine aus Quellcode 4 verantwortlich. Sie greift über das VBE-Objekt auf die im VBA-Projekt enthaltenen Elemente zu (hierfür ist im übrigen ein Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 erforderlich).<\/p>\n
    Da das Tool später als Add-In ausgelegt werden soll, ist es wichtig, festzulegen, dass dabei nicht das eigene VBA-Projekt, sondern das VBA-Projekt der Datenbank, die das Tool aufruft, referenziert wird. Dies wird dadurch sichergestellt, dass die Routine alle aktuell enthaltenen VBA-Projekte durchläuft und nur diejenigen berücksichtigt, die nicht den Namen Performance-Tester haben. <\/p>\n
    Alles Weitere ist Fleißarbeit; genauere Informationen über die hier verwendeten VBA-Anweisungen finden Sie im Beitrag Per VBA auf VBA-Code zugreifen (s. Shortlink 278).<\/p>\n
    Quellcode 3: Aufruf der Funktion zum Füllen des Kombinationsfeldes mit den Modulen<\/b><\/p>\n
    Private Sub Form_Open(Cancel As Integer)\r\n    Me!cboModule.RowSource = ModuleEinlesen\r\nEnd Sub<\/pre>\n
    Auswahl der Funktionen<\/h3>\n
    Bevor der Benutzer die zu vergleichenden Funktionen auswählen kann, müssen Sie für das Füllen der entsprechenden Kombinationsfelder sorgen. Hier tritt die Ereignisprozedur auf den Plan, die nach dem Aktualisieren des Kombinationsfeldes cboModule ausgelöst wird. Diese ermittelt zunächst den Namen des Moduls und des Projekts, deren Routinen aufgelistet werden sollen. Die Funktion RoutinenEinlesen ermittelt – ähnlich wie die Routine ModuleEinlesen – die in dem angegebenen Modul enthaltenen Routinen.<\/p>\n
    Quellcode 5: Nach dem Aktualisieren des Kombinationsfeldes cboModule werden die übrigen Kombinationsfelder mit den Routinennamen des ausgewählten Moduls gefüllt.<\/b><\/p>\n
    Private Sub cboModule_AfterUpdate()\r\n    Dim strModulname As String\r\n    Dim strProjektname As String\r\n    Dim strRoutinen As String\r\n    strModulname = Me!cboModule\r\n    strProjektname = Me!cboModule.Column(3)\r\n    strRoutinen = RoutinenEinlesen(strProjektname, strModulname)\r\n    Me!cboRoutine1.RowSource = strRoutinen\r\n    Me!cboRoutine1 = \"\"\r\n    Me!cboRoutine2.RowSource = strRoutinen\r\n    Me!cboRoutine2 = \"\"\r\n    Me!cboRoutineReferenz.RowSource = strRoutinen\r\n    Me!cboRoutineReferenz = \"\"\r\nEnd Sub<\/pre>\n
    Quellcode 6: Performance-Messung und Auswertung (1. Teil)<\/b><\/p>\n
    Private Sub cmdTestStarten_Click()\r\n    Dim objZeitmessung As clsZeitmessung\r\n    Dim strModulename As String\r\n    Dim lngModuleType As Long\r\n    Dim obj As Object\r\n    DoCmd.Hourglass True\r\n    ''Validierungsfunktionen aus Platzgründen nicht abgedruckt\r\n    Set objZeitmessung = New clsZeitmessung\r\n    strModulename = Me!cboModule.Column(0)\r\n    lngModuleType = Me!cboModule.Column(2)\r\n    With objZeitmessung\r\n        .AnzahlDurchgaenge = Me.txtAnzahlDurchgaenge\r\n        Select Case lngModuleType\r\n            Case 1 ''Standardmodul\r\n                .ErsteProzedur = Me!cboRoutine1 & \"()\"\r\n                .ZweiteProzedur = Me!cboRoutine2 & \"()\"\r\n                If Me.chkReferenzfunktion = True Then\r\n                    .Referenzprozedur = _                        Me!cboRoutineReferenz & \"()\"\r\n                    .MitReferenzzeit = True\r\n                End If\r\n                .Performancetest_Standard\r\n            Case 100 ''Formular oder Bericht\r\n                .ErsteProzedur = Me!cboRoutine1\r\n                .ZweiteProzedur = Me!cboRoutine2\r\n                If Me.chkReferenzfunktion = True Then\r\n                    .Referenzprozedur = Me!cboRoutineReferenz\r\n                    .MitReferenzzeit = True\r\n                End If\r\n                If Left(strModulename, 4) = \"Form\" Then\r\n                    DoCmd.OpenForm Mid(strModulename, 6)\r\n                    Set .Objekt = Forms(Mid(strModulename, 6))\r\n                    .Performancetest_Objekt\r\n                    DoCmd.Close acForm, Mid(strModulename, 6)\r\n                End If\r\n            Case Else\r\n                MsgBox \"Modultyp nicht identifizierbar.\", _                    vbExclamation Or vbOKOnly\r\n                Exit Sub\r\n        End Select<\/pre>\n
    Aus Platzgründen kann der Inhalt dieser Funktion hier nicht abgebildet werden. Sie finden den Quellcode jedoch in der Beispieldatenbank. Die Zeichenkette mit der Liste der Routinen wird nach dem Einlesen in der Variablen strRoutinen gespeichert und anschließend der Eigenschaft RowSource der drei übrigen Kombinationsfelder zugewiesen. Deren Eigenschaften Spaltenanzahl, Spaltenbreiten und Herkunftsart stellen Sie auf 2, 5cm;5cm und Wertliste ein.<\/p>\n
    Mit oder ohne Referenzfunktion<\/h3>\n
    Mit dem Kontrollkästchen chkMitReferenzfunktion legt der Benutzer fest, ob er eine Referenzfunktion verwenden möchte. Das Aktivieren oder Deaktivieren dieser Option bewirkt das Auslösen des Ereignisses Nach Aktualisierung. Diese wiederum sorgt dafür, dass die für die Eingabe der Referenzfunktion notwendigen Steuerelemente je nach dem Wert des Optionsfeldes entweder aktiviert oder deaktiviert werden.<\/p>\n
    Starten der Performance-Messung<\/h3>\n
    Fehlt nur noch die eigentliche Funktion des Formulars: das Aufrufen und Ausführen der Performance-Messung. Diese Funktion teilen sich die Routine, die durch das Anklicken der Schaltfläche cmdTestStarten ausgelöst wird, sowie die Klasse clsZeitmessung. <\/p>\n
    Betrachten Sie zunächst die durch den Klick auf die Schaltfläche cmdTestStarten ausgelöste Prozedur (s. Quellcode 6). Diese validiert zunächst die Eingaben im Formular frmPerformance (aus Platzgründen nicht abgedruckt).<\/p>\n
    Quellcode 6: Performance-Messung und Auswertung (Fortsetzung)<\/b><\/p>\n
            If Me.chkReferenzfunktion = False Then\r\n            Me!txtZeit1 = .ErsteZeit\r\n            Me!txtZeit2 = .ZweiteZeit\r\n            Me!txtAbsoluteDifferenz1 = .ZweiteZeit - .ErsteZeit\r\n            Me!txtRelativeDifferenz1 = Format((.ZweiteZeit - .ErsteZeit) \/ .ZweiteZeit, \"0.00%\")\r\n            Me!txtAbsoluteDifferenz2 = .ErsteZeit - .ZweiteZeit\r\n            Me!txtRelativeDifferenz2 = Format((.ErsteZeit - .ZweiteZeit) \/ .ErsteZeit, \"0.00%\")\r\n        Else\r\n            Me!txtZeit1 = .ErsteZeit - .Referenzzeit & \" (\" & .ErsteZeit & \")\"\r\n            Me!txtZeit2 = .ZweiteZeit - .Referenzzeit & \" (\" & .ZweiteZeit & \")\"\r\n            Me.txtZeitReferenz = .Referenzzeit\r\n            Me!txtAbsoluteDifferenz1 = .ZweiteZeit - .ErsteZeit\r\n            Me!txtRelativeDifferenz1 = Format((.ZweiteZeit - .ErsteZeit - 2 * .Referenzzeit) _                \/ (.ZweiteZeit - .Referenzzeit), \"0.00%\") _                & \" (\" & Format((.ZweiteZeit - .ErsteZeit) \/ .ZweiteZeit, \"0.00%\") & \")\"\r\n            Me!txtAbsoluteDifferenz2 = .ErsteZeit - .ZweiteZeit\r\n            Me!txtRelativeDifferenz2 = Format((.ErsteZeit - .ZweiteZeit - 2 * .Referenzzeit) _                \/ (.ErsteZeit - .Referenzzeit), \"0.00%\") _                    & \" (\" & Format((.ErsteZeit - .ZweiteZeit) \/ .ErsteZeit, \"0.00%\") & \")\"\r\n        End If\r\n        Me!picGreen1.Visible = .ErsteZeit < .ZweiteZeit\r\n        Me!picGreen2.Visible = .ErsteZeit > .ZweiteZeit\r\n        Me!picRed1.Visible = .ErsteZeit > .ZweiteZeit\r\n        Me!picRed2.Visible = .ErsteZeit < .ZweiteZeit\r\n        Me!picRedGreen1.Visible = .ErsteZeit = .ZweiteZeit\r\n        Me!picRedGreen2.Visible = .ErsteZeit = .ZweiteZeit\r\n    End With\r\n    DoCmd.Hourglass False\r\nEnd Sub<\/pre>\n
    Anschließend instanziert die Prozedur ein Objekt der Klasse clsZeitmessung. Das Objekt stellt einige Eigenschaften für das Zuweisen von Informationen wie der Anzahl der Durchgänge, der Namen der zu testenden Routinen und des Moduls, zu dem diese Routinen gehören, zur Verfügung.<\/p>\n
    In einem Select Case-Konstrukt prüft die Prozedur, ob die Routinen aus einem Standardmodul oder einem Formular-Klassenmodul stammen und ruft die entsprechende Methode zum Messen der Performance auf. Dabei berücksichtigt die Prozedur auch eine gegebenenfalls angegebene Referenzfunktion.<\/p>\n
    Die Ergebnisse der Messung können anschließend aus den drei Eigenschaften ErsteZeit, ZweiteZeit und Referenzzeit der Klasse clsZeitmessung ausgelesen werden.<\/p>\n
    Die Prozedur gibt die für die einzelnen Funktionen ermittelten Zeiten aus und berechnet weitere Ergebnisse wie die absolute und die relative Differenz zwischen den Ergebnissen.<\/p>\n
    Falls eine Referenzfunktion angegeben ist, wird diese in die Berechnung mit einbezogen.<\/p>\n
    Das Klassenmodul clsZeitmessung<\/h2>\n
    Das Klassenmodul kapselt die Funktionen zur Zeitmessung. Es enthält die Deklaration der hierbei verwendeten API-Funktion QueryPerformanceCounter, einige Member-Variablen, die Property-Prozeduren zum Setzen und Lesen der Eigenschaften der Klasse sowie die beiden Methoden zum Ermitteln der für das Ausführen von zwei verschiedenen Funktionen zuzüglich einer optionalen Referenzfunktion benötigten Zeiten (s. Quellcode 7).<\/p>\n
    Quellcode 7: Die Klasse clsZeitmessung<\/b><\/p>\n
    Private Declare Function QueryPerformanceCounter Lib _    \"kernel32.dll\" (ByRef lpPerformanceCount As Currency) _    As Long\r\nPrivate Declare Function QueryPerformanceFrequency Lib _    \"kernel32.dll\" (ByRef lpFrequency As Currency) _As Long\r\n''Deklaration - aus Platzgründen nicht abgedruckt\r\n''Property-Prozeduren - aus Platzgründen nicht abgedruckt\r\nPrivate Sub Class_Initialize()\r\n    ''Ermitteln der rechnerspezifischen Counter-Frequenz\r\n    QueryPerformanceFrequency mFreq\r\nEnd Sub\r\nPrivate Sub Starten()\r\n    QueryPerformanceCounter curStartzeit\r\nEnd Sub\r\nPrivate Sub Stoppen()\r\n    Dim curStop As Currency\r\n    QueryPerformanceCounter curStop\r\n    ''Umrechnung Counter in Millisekunden über Counterfrequenz\r\n    mZeit = (curStop - curStartzeit) \/ mFreq * 1000\r\nEnd Sub\r\nPublic Sub Performancetest_Standard()\r\n    Dim l As Long\r\n    Starten\r\n    For l = 1 To mAnzahlDurchgaenge\r\n        Application.Run mErsteProzedur\r\n    Next l\r\n    Stoppen\r\n    mErsteZeit = mZeit\r\n    Starten\r\n    For l = 1 To mAnzahlDurchgaenge\r\n        Application.Run mZweiteProzedur\r\n    Next l\r\n    Stoppen\r\n    mZweiteZeit = mZeit\r\n    If mErsteZeit = 0 Or mZweiteZeit = 0 Then\r\n        Debug.Print \"###Zeit nicht messbar, \" _            & \"AnzahlDurchgaenge erhöhen.\"\r\n    Else\r\n        mAbsoluteDifferenz = (mZweiteZeit - mErsteZeit)\r\n        mRelativeDifferenz = AbsoluteDifferenz \/ _            mZweiteZeit * 100\r\n    End If\r\nEnd Sub\r\nPublic Sub Performancetest_Objekt()\r\n    Dim l As Long\r\n    Starten\r\n    For l = 1 To mAnzahlDurchgaenge\r\n        CallByName mObjekt, mErsteProzedur, VbMethod\r\n    Next l\r\n    Stoppen\r\n    mErsteZeit = mZeit\r\n    Starten\r\n    For l = 1 To mAnzahlDurchgaenge\r\n        CallByName mObjekt, mZweiteProzedur, VbMethod\r\n    Next l\r\n    Stoppen\r\n    mZweiteZeit = mZeit\r\n    If mErsteZeit = 0 Or mZweiteZeit = 0 Then\r\n        Debug.Print \"###Zeit nicht messbar, \" _            & \"AnzahlDurchgaenge erhöhen.\"\r\n    Else\r\n        mAbsoluteDifferenz = (mZweiteZeit - mErsteZeit)\r\n        mRelativeDifferenz = AbsoluteDifferenz \/ _            mZweiteZeit * 100\r\n    End If\r\nEnd Sub<\/pre>\n
    Die Deklaration der Variablen sowie die Property-Prozeduren wurden nicht abgedruckt; Sie finden diese allerdings im Klassenmodul clsZeitmessung der Beispieldatenbank. Interessanter sind die Methoden Performancetest_Standard und Performancetest_Object sowie die beiden Routinen zum Ermitteln der Start- und Endzeit.<\/p>\n
    Aufruf der zu testenden Funktionen<\/h3>\n
    Die beiden Methoden weisen als einzigen Unterschied die Art des Aufrufs der Funktion auf. Wenn es sich um eine öffentliche Funktion in einem Standardmodul handelt, kann man diese einfach ausführen. Eine Routine in einem Formular muss hingegen unter Angabe eines Objektverweises auf das geöffnete Formular mit der Anweisung CallByName aufgerufen werden. Die Zeitmessung erfolgt in drei Schritten:<\/p>\n
  • Starten der Messung (Speichern des Startzeitpunktes mit der Prozedur Starten)<\/li>\n
  • Aufrufen der Funktion in der gewünschten Anzahl<\/li>\n
  • Stoppen der Messung (Speichern des Endzeitpunktes mit der Prozedur Stoppen).<\/li>\n
    Damit das Tool von anderen Datenbanken aus als Add-In aufgerufen werden kann, sind folgende Schritte notwendig (s. Beitrag Assistenten und Add-Ins selbst gebaut, Shortlink 101):<\/p>\n
    <\/p>\n
    <\/b><\/p>\n
    Bild 4:  Die Tabelle USysRegInfo mit den Registry-Informationen für das neue Add-In<\/span><\/b><\/p>\n
    Quellcode 8: Diese Funktion wird beim Aufrufen des Add-Ins gestartet.<\/b><\/p>\n
    Public Function StartPerformanceTest()\r\n    DoCmd.OpenForm \"frmPerformance\"\r\nEnd Function<\/pre>\n
    Wenn Sie den Eindruck haben, dass Ihre Anwendung keine optimale Performance aufweist, sollten Sie die Gründe dafür finden und die Probleme beheben. Ob sich die änderungen und die damit verbundene Arbeit lohnen, sollten Sie nur in Ausnahmefällen „nach Gefühl“ entscheiden – knallharte Zahlen sind hier der bessere Berater. Und mit dem hier vorgestellten Add-In haben Sie sogar ein Tool zur Hand, das Ihnen schnell Ergebnisse liefert.<\/p>\n
    Seien Sie allerdings vorsichtig bei der Interpretation der Messergebnisse: Sorgen Sie für gleiche Voraussetzungen für die zu vergleichenden Optionen und testen Sie vor allem unter realen Bedingungen – es hilft Ihnen nicht weiter, wenn Sie verschiedene Varianten des Aufrufs einer Abfrage mit wenigen Datensätzen testen, aber in der Praxis Millionen von Datensätzen zu durchforsten sind. Das Schaffen idealer Voraussetzungen für Performance-Tests würde Stoff für einen eigenen Beitrag liefern und an dieser Stelle den Rahmen sprengen, daher wird Access im Unternehmen dieses Thema gegebenenfalls in einem der nachfolgenden Magazine aufgreifen.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Die Performance einer Datenbankanwendung ist mithin ein entscheidender Faktor für die Akzeptanz beim Benutzer. Muss dieser bei bestimmten Aktionen länger als ein paar Sekunden auf die Anwendung warten, stellt sich schnell Unzufriedenheit ein. Nun dreht es sich in diesem Beitrag nicht um die Optimierung der Performance, sondern um die Messung der Resultate von Performance-Optimierungen. Und dabei erfahren Sie, wie Sie sich ein nützliches Add-In zur Messung der Performance bauen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66012006,662006,44000028,44000027],"tags":[],"class_list":["post-55000327","post","type-post","status-publish","format-standard","hentry","category-66012006","category-662006","category-Ergonomie_und_Benutzeroberflaeche","category-Loesungen"],"yoast_head":"\nPerformance-Tester als Access-Add-In - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Performance-Tester als Access-Add-In\" \/>\n<meta property=\"og:description\" content=\"Die Performance einer Datenbankanwendung ist mithin ein entscheidender Faktor für die Akzeptanz beim Benutzer. Muss dieser bei bestimmten Aktionen länger als ein paar Sekunden auf die Anwendung warten, stellt sich schnell Unzufriedenheit ein. Nun dreht es sich in diesem Beitrag nicht um die Optimierung der Performance, sondern um die Messung der Resultate von Performance-Optimierungen. Und dabei erfahren Sie, wie Sie sich ein nützliches Add-In zur Messung der Performance bauen.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-06T15:18:15+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg05.met.vgwort.de\/na\/970e156ef4454012ae5deeec6d3b7495\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"16\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Performance-Tester als Access-Add-In\",\"datePublished\":\"2020-05-06T15:18:15+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/\"},\"wordCount\":2512,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/970e156ef4454012ae5deeec6d3b7495\",\"articleSection\":[\"1\\\/2006\",\"2006\",\"Ergonomie und Benutzeroberfl\u00e4che\",\"L\u00f6sungen\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/\",\"name\":\"Performance-Tester als Access-Add-In - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/970e156ef4454012ae5deeec6d3b7495\",\"datePublished\":\"2020-05-06T15:18:15+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/970e156ef4454012ae5deeec6d3b7495\",\"contentUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/970e156ef4454012ae5deeec6d3b7495\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/PerformanceTester_als_AccessAddIn\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Performance-Tester als Access-Add-In\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Performance-Tester als Access-Add-In - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/","og_locale":"de_DE","og_type":"article","og_title":"Performance-Tester als Access-Add-In","og_description":"Die Performance einer Datenbankanwendung ist mithin ein entscheidender Faktor für die Akzeptanz beim Benutzer. Muss dieser bei bestimmten Aktionen länger als ein paar Sekunden auf die Anwendung warten, stellt sich schnell Unzufriedenheit ein. Nun dreht es sich in diesem Beitrag nicht um die Optimierung der Performance, sondern um die Messung der Resultate von Performance-Optimierungen. Und dabei erfahren Sie, wie Sie sich ein nützliches Add-In zur Messung der Performance bauen.","og_url":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/","og_site_name":"Access im Unternehmen","article_published_time":"2020-05-06T15:18:15+00:00","og_image":[{"url":"http:\/\/vg05.met.vgwort.de\/na\/970e156ef4454012ae5deeec6d3b7495","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"16\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Performance-Tester als Access-Add-In","datePublished":"2020-05-06T15:18:15+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/"},"wordCount":2512,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#primaryimage"},"thumbnailUrl":"http:\/\/vg05.met.vgwort.de\/na\/970e156ef4454012ae5deeec6d3b7495","articleSection":["1\/2006","2006","Ergonomie und Benutzeroberfl\u00e4che","L\u00f6sungen"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/","url":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/","name":"Performance-Tester als Access-Add-In - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#primaryimage"},"thumbnailUrl":"http:\/\/vg05.met.vgwort.de\/na\/970e156ef4454012ae5deeec6d3b7495","datePublished":"2020-05-06T15:18:15+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#primaryimage","url":"http:\/\/vg05.met.vgwort.de\/na\/970e156ef4454012ae5deeec6d3b7495","contentUrl":"http:\/\/vg05.met.vgwort.de\/na\/970e156ef4454012ae5deeec6d3b7495"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/PerformanceTester_als_AccessAddIn\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Performance-Tester als Access-Add-In"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000327","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000327"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000327\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000327"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000327"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000327"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}