![\"Einfacher](\"..\/fileadmin\/_temp_\/2026_01\/pic_498_003.png\")
<\/p>\nUnter Access kennt man eigentlich nur den Timer, den das Formular-Objekt mitbringt. Damit können wir ein Ereignis definieren, das in einem bestimmten Zeitintervall ausgelöst wird. Was aber, wenn wir einen Timer einmal außerhalb des Kontexts eines Formulars benötigen? Dann erstellen wir uns einfach eine eigene Timer-Klasse. Dazu sind zwar ein paar Tricks und API-Funktionen nötig, aber das soll kein Hindernis sein. Deshalb zeigen wir in diesem Beitrag im Detail, wie das gelingt und wie sich dieser Timer in der Praxis einsetzen lässt. Und im Gegensatz zum Formulartimer haben wir noch einen Vorteil: Wir können nämlich nicht nur einen, sondern beliebig viele Timer einsetzen und laufen lassen.<\/b><\/p>\nKlassischer Formular-Timer in Access<\/h2>\n
Wenn wir in Access einen Timer benötigen, ist das eigentlich nur über den Formular-Timer möglich. Dazu fügt man einem Formular das Ereignis Bei Zeitgeber <\/b>hinzu und legt mit der Eigenschaft Zeitgeberintervall <\/b>fest, in welchen Intervallen dieses Ereignis ausgelöst werden soll (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Einfacher Formulartimer<\/span><\/b><\/p>\n In der Ereignisprozedur tragen wir den Code ein, der beim Eintreten des Ereignisses Form_Timer <\/b>ausgelöst werden soll. In diesem Fall aktualisieren wir alle 1.000 Millisekunden die Anzeige der Uhrzeit:<\/p>\n Wenn der Timer nicht mehr ausgelöst werden soll, stellen wir die Eigenschaft Zeitgeberintervall <\/b>per VBA auf 0 <\/b>ein:<\/p>\n Ein Timer ist allerdings manchmal nicht ausreichend. Wenn man nicht mehrere Formulare mit einem Timer ausstatten will, muss man sich also eine andere Lösung überlegen. Außerdem gibt es auch Anwendungsfälle, in denen gerade kein Formular geöffnet ist, das den Timer zur Verfügung stellen kann. Was ist zum Beispiel, wenn man regelmäßig einen bestimmten Status im Ribbon aktualisieren möchte?<\/p>\n Für solche Anwendungsfälle stellen wir nun eine Lösung vor, mit der wir bis zu 100 Timer unabhängig voneinander starten, auslösen und beenden können.<\/p>\n Dazu benötigen wir eine Klasse, die den Timer selbst enthält. Zudem benötigen wir ein paar Zeilen Code, um die Timer zu initialisieren und die dadurch ausgelösten Ereignisse zu implementieren.<\/p>\n Die Klasse, welche die Timer bereitstellt, heißt CLS_AMV_Timer <\/b>und ist in Listing 1 zu finden. Sie deklariert zunächst das Ereignis, das durch den Timer ausgelöst wird:<\/p>\n Listing 1: Klassenmodul CLS_AMV_Timer<\/span><\/b><\/p>\n Die Variablen L_INTERVAL <\/b>und L_ID <\/b>speichern das Intervall eines Timers und die ID:<\/p>\n Die Prozedur ErrRaise <\/b>wird beim Auftreten eines Fehlers aufgerufen.<\/p>\n Über die Property Get<\/b>-Prozedur Interval können wir das Intervall eines Timers abrufen, mit der entsprechenden Property Let<\/b>-Prozedur setzen wir das Intervall.<\/p>\n Dabei übergeben wir die Anzahl der Millisekunden, nach denen der Timer ausgelöst werden soll. Die Prozedur prüft, ob das Intervall größer als 0 <\/b>ist, und stellt dieses ein. Wenn das zugewiesene Intervall gleich dem zuvor eingestellten Intervall ist, wird die Prozedur verlassen. Anderenfalls rufen wir die Prozedur TimerDestroy <\/b>auf, die im Standardmodul MDL_AMV_Timer <\/b>enthalten ist (siehe weiter unten).<\/p>\n Die Methode RaiseInterval <\/b>löst das Ereignis TimerEvent <\/b>aus, das wir im implementierenden Klassenmodul definieren. Schließlich gibt es noch zwei Property<\/b>-Prozeduren, mit denen die TimerID <\/b>gelesen und geschrieben werden kann, und die Methode Class_Terminate<\/b>, welche das Intervall auf 0 <\/b>Millisekunden einstellt.<\/p>\n Damit kommen wir zum zweiten Modul, das für die Verwendung der Klasse wichtig ist.<\/p>\n Das Modul MOD_AMV_TIMER <\/b>enthält alle Funktionen, um die Windows-Timer zu starten und zu stoppen. Es sorgt dafür, dass bis zu 100 Timer gleichzeitig verwaltet werden können. Diese enthält zunächst einige Deklarationen (siehe Listing 2).<\/p>\n Listing 2: Deklarationen im Modul MDL_AMV_Timer<\/span><\/b><\/p>\n Diese Deklarationen stellen sicher, dass wir die Windows-Timer-API sowohl in 32-Bit- als auch in 64-Bit-Umgebungen verwenden können. Das Enum eTimerError <\/b>definiert eigene Fehlercodes für die Klasse.<\/p>\n cTimerMax <\/b>legt die maximale Anzahl gleichzeitig laufender Timer fest. Das Array aTimers <\/b>speichert Referenzen auf alle Timer<\/b>-Objekte. cTimerCount <\/b>gibt an, wie viele Timer aktuell verwendet werden.<\/p>\n In der Funktion TimerCreate <\/b>wird der Windows-Timer über die API-Funktion SetTimer <\/b>erstellt (siehe Listing 3).<\/p>\n Listing 3: Die Funktion TimerCreate<\/span><\/b><\/p>\n Anschließend suchen wir einen freien Platz im Array aTimers<\/b>. Bei Erfolg speichern wir das Objekt, andernfalls wird ein Fehler geworfen.<\/p>\n Diese Funktion TimerDestroy <\/b>sucht im Array den passenden Timer anhand der ID, beendet ihn mit KillTimer <\/b>und entfernt die Referenz (siehe Listing 4).<\/p>\n Listing 4: Die Funktion TimerDestroy<\/span><\/b><\/p>\n Windows ruft diese Prozedur auf, wenn ein Timer abgelaufen ist. Die Prozedur sucht den passenden Timer und ruft dessen Methode RaiseInterval <\/b>auf, damit die Klasse das Event auslösen kann (siehe Listing 5).<\/p>\n Listing 5: Die Funktion TimerProc<\/span><\/b><\/p>\n Wenn wir auf einen Timer reagieren wollen, indem wir für diesen eine Ereignisprozedur implementieren, benötigen wir zwingend ein Klassenmodul. Wir haben uns zur Vereinfachung entschieden, dazu das Klassenmodul eines Formulars zu nutzen.<\/p>\n In diesem Klassenmodul haben wir den Code aus Listing 6 hinterlegt. Hier werden zunächst drei Objekte der Klasse CLS_AMV_TIMER <\/b>mit WithEvents <\/b>deklariert. Dadurch können wir auf das Ereignis TimerEvent <\/b>reagieren:<\/p>\n Listing 6: Klassenmodul des Formulars FRM_CLASS_TIMER<\/span><\/b><\/p>\n Im Form_Load <\/b>werden die Timer gestartet. Dazu erstellen wir mit New CLS_AMV_TIMER <\/b>jeweils eine neue Instanz der Klasse CLS_AMV_Timer <\/b>und weisen diese den Variablen C_TIMER01<\/b>, C_TIMER02 <\/b>und C_TIMER03 <\/b>zu.<\/p>\n Dann stellen wir die Eigenschaft Interval<\/b> jeweils auf 1.000 Millisekunden ein, damit die Timer einmal pro Sekunde ausgelöst werden.<\/p>\n Nun müssen wir noch die Ereignisse implementieren, in denen wir den Code unterbringen, der beim Auslösen des Timers ausgeführt werden soll.<\/p>\n Dazu wählen wir im linken Kombinationsfeld im Codefenster den Eintrag für den jeweiligen Timer aus, zum Beispiel C_TIMER01<\/b>.<\/p>\n Im rechten Kombinationsfeld wird jetzt automatisch das einzige Ereignis der Timer<\/b>-Klasse ausgewählt und es erscheint die entsprechende Ereignisprozedur im Codefenster (siehe Bild 2). Diese füllen wir mit dem gewünschten Code, zum Beispiel:<\/p>\n Bild 2: Implementieren des TimerEvent-Ereignisses für einen Timer<\/span><\/b><\/p>\n Hier soll das Bezeichnungsfeld mit dem Namen LB01 <\/b>mit dem aktuellen Datum und der Uhrzeit in einem bestimmten Format gefüllt werden. Im Unload<\/b>-Ereignis werden die Timer schließlich gestoppt. Dazu stellen wir ihre Eigenschaft Interval <\/b>auf 0 <\/b>ein und leeren die Objektvariablen. So bleibt kein Timer aktiv und der Speicher wird bereinigt. Das Ergebnis sehen wir in Bild 3.<\/p>\n Bild 3: Das Formular mit drei Timern in Aktion<\/span><\/b><\/p>\n Wie im Titel dieses Artikels angekündigt, wollen wir aber auch Timer vollkommen unabhängig von einem Formular starten können. Das bedeutet lediglich, dass wir den Code, der das TimerEvent<\/b>-Ereignis implementiert, in einem Klassenmodul implementieren müssen.<\/p>\n Also kopieren wir den Inhalt aus dem Klassenmodul des Formulars in ein neues Klassenmodul namens clsTimerBeispiel<\/b>. Hier können wir die Deklarationen und die Implementierungen des Ereignisses Private Sub <\/span>Form_Timer()\r\n Me.txtUhrzeit = Time()\r\nEnd Sub<\/span><\/pre>\nMe.TimerInterval = 0<\/pre>\n
Wenn mehr als ein Timer benötigt wird …<\/h2>\n
Die Klasse CLS_AMV_Timer<\/h2>\n
Public <\/span>Event TimerEvent()\r\nPrivate <\/span>L_INTERVAL As Long<\/span>\r\nPrivate <\/span>L_ID As Long<\/span>Ptr\r\nFriend Sub <\/span>ErrRaise(E As Long<\/span>)\r\n Dim <\/span>sText As String<\/span>\r\n Dim <\/span>sSource As String<\/span>\r\n If <\/span>E > 1000 Then<\/span>\r\n sSource = \"Application\" & \".WindowProc\"\r\n Select Case E\r\n Case <\/span>eTooManyTimers\r\n sText = \"No more than 1000 timers allowed per class\"\r\n Case <\/span>eCantCreateTimer\r\n sText = \"Can''t create system timer\"\r\n End Select<\/span>\r\n Err.Raise E Or vbObjectError, sSource, sText\r\n Else<\/span>\r\n Err.Raise E, sSource\r\n End If \r\nEnd Sub<\/span>\r\nProperty Get <\/span>Interval() As Long<\/span>\r\n Interval = L_INTERVAL\r\nEnd Property<\/span>\r\nProperty Let <\/span>Interval(lValue As Long<\/span>)\r\n Dim <\/span>b As Boolean<\/span> \r\n If <\/span>lValue > 0 Then<\/span>\r\n If <\/span>L_INTERVAL = lValue Then<\/span> Exit Property<\/span>\r\n If <\/span>L_INTERVAL Then<\/span>\r\n b = TimerDestroy(Me)\r\n Debug.Assert<\/span> b\r\n End If<\/span>\r\n L_INTERVAL = lValue\r\n If <\/span>TimerCreate(Me) = False<\/span> Then<\/span>\r\n ErrRaise eCantCreateTimer\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>(L_INTERVAL > 0) Then<\/span>\r\n L_INTERVAL = 0\r\n b = TimerDestroy(Me)\r\n Debug.Assert<\/span> b\r\n End If<\/span>\r\n End If \r\nEnd Property<\/span>\r\nPublic Sub <\/span>RaiseInterval()\r\n RaiseEvent TimerEvent\r\nEnd Sub<\/span>\r\nFriend Property Get <\/span>TimerID() As Long<\/span>Ptr\r\n TimerID = L_ID\r\nEnd Property<\/span>\r\nFriend Property Let <\/span>TimerID(ID As Long<\/span>Ptr)\r\n L_ID = ID\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>Class_Terminate()\r\n Interval = 0\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>Event TimerEvent()<\/pre>\nPrivate <\/span>L_INTERVAL As Long<\/span>\r\nPrivate <\/span>L_ID As Long<\/span>Ptr<\/pre>\nPrivate Sub <\/span>Class_Terminate()\r\n Interval = 0\r\nEnd Sub<\/span><\/pre>\nModul MOD_AMV_TIMER: Verwaltung der Timer<\/h2>\n
Public <\/span>Enum eTimerError\r\n eBaseTimer = 10100\r\n eTooManyTimers = 10101\r\n eCantCreateTimer = 10102\r\nEnd Enum\r\n#If Win64 Then\r\n Public <\/span>Declare PtrSafe Function SetTimer Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr, ByVal nIDEvent As Long<\/span>Ptr, _\r\n ByVal uElapse As Long<\/span>, ByVal lpTimerFunc As Long<\/span>Ptr) As Long<\/span>Ptr\r\n Public <\/span>Declare PtrSafe Function KillTimer Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr, ByVal nIDEvent As Long<\/span>Ptr) As Long<\/span>\r\n#Else\r\n Public <\/span>Declare Function SetTimer Lib \"user32\" (ByVal hWnd As Long<\/span>, ByVal nIDEvent As Long<\/span>, _\r\n ByVal uElapse As Long<\/span>, ByVal lpTimerFunc As Long<\/span>) As Long<\/span>\r\n Public <\/span>Declare Function KillTimer Lib \"user32\" (ByVal hWnd As Long<\/span>, ByVal nIDEvent As Long<\/span>) As Long<\/span>\r\n#End If\r\nPrivate <\/span>Const cTimerMax As Long<\/span> = 100\r\nPrivate <\/span>aTimers(1 To cTimerMax) As <\/span>CLS_AMV_TIMER\r\nPrivate <\/span>cTimerCount As Integer<\/span><\/pre>\nTimer erstellen<\/h2>\n
Public Function <\/span>TimerCreate(Timer As <\/span>CLS_AMV_TIMER) As Boolean<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n On Error Resume Next<\/span>\r\n Timer.TimerID = SetTimer(CLngPtr(0), CLngPtr(0), Timer.Interval, AddressOf TimerProc)\r\n If <\/span>Timer.TimerID Then<\/span>\r\n TimerCreate = True<\/span>\r\n For i = 1 To cTimerMax\r\n If <\/span>aTimers(i) Is Nothing Then<\/span>\r\n Set<\/span> aTimers(i) = Timer\r\n If <\/span>i > cTimerCount Then<\/span> cTimerCount = i\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span>\r\n Timer.ErrRaise eTooManyTimers\r\n Else<\/span>\r\n Timer.TimerID = 0\r\n Timer.Interval = 0\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nTimer zerstören<\/h2>\n
Public Function <\/span>TimerDestroy(Timer As <\/span>CLS_AMV_TIMER) As Long<\/span>\r\n Dim <\/span>i As Integer<\/span>, f As Boolean<\/span>\r\n On Error Resume Next<\/span>\r\n For i = 1 To cTimerCount\r\n If <\/span>Not<\/span> aTimers(i) Is Nothing Then<\/span>\r\n If <\/span>Timer.TimerID = aTimers(i).TimerID Then<\/span>\r\n f = KillTimer(CLngPtr(0), Timer.TimerID)\r\n Set<\/span> aTimers(i) = Nothing\r\n TimerDestroy = True<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span>\r\nEnd Function<\/span><\/pre>\nDie Prozedur TimerProc<\/h2>\n
Public Sub <\/span>TimerProc(ByVal hWnd As Long<\/span>Ptr, ByVal uMsg As Long<\/span>, ByVal nIDEvent As Long<\/span>Ptr, ByVal dwTime As Long<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n On Error Resume Next<\/span>\r\n For i = 1 To cTimerCount\r\n If <\/span>Not<\/span> (aTimers(i) Is Nothing) Then<\/span>\r\n If <\/span>nIDEvent = aTimers(i).TimerID Then<\/span>\r\n aTimers(i).RaiseInterval\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nBeispiel: Das Formular FRM_CLASS_TIMER<\/h2>\n
Private <\/span>WithEvents C_TIMER01 As <\/span>CLS_AMV_TIMER\r\nPrivate <\/span>WithEvents C_TIMER02 As <\/span>CLS_AMV_TIMER\r\nPrivate <\/span>WithEvents C_TIMER03 As <\/span>CLS_AMV_TIMER\r\nPrivate Sub <\/span>C_TIMER01_TimerEvent()\r\n Me.LB01.Caption = Format(Now, \"dd mm yyyy hh:nn:ss\")\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>C_TIMER02_TimerEvent()\r\n Me.LB02.Caption = Format(Now, \"dd mm yyyy hh:nn:ss\")\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>C_TIMER03_TimerEvent()\r\n Me.LB03.Caption = Format(Now, \"dd mm yyyy hh:nn:ss\")\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Load()\r\n \r\n Set<\/span> C_TIMER01 = New<\/span> CLS_AMV_TIMER\r\n Set<\/span> C_TIMER02 = New<\/span> CLS_AMV_TIMER\r\n Set<\/span> C_TIMER03 = New<\/span> CLS_AMV_TIMER\r\n \r\n C_TIMER01.Interval = 1000\r\n C_TIMER02.Interval = 1000\r\n C_TIMER03.Interval = 1000\r\n \r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n C_TIMER01.Interval = 0\r\n C_TIMER02.Interval = 0\r\n C_TIMER03.Interval = 0\r\n Set<\/span> C_TIMER01 = Nothing\r\n Set<\/span> C_TIMER02 = Nothing\r\n Set<\/span> C_TIMER03 = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents C_TIMER01 As <\/span>CLS_AMV_TIMER\r\nPrivate <\/span>WithEvents C_TIMER02 As <\/span>CLS_AMV_TIMER\r\nPrivate <\/span>WithEvents C_TIMER03 As <\/span>CLS_AMV_TIMER<\/pre>\n![\"Implementieren](\"..\/fileadmin\/_temp_\/2026_01\/pic_498_002.png\")
<\/p>\nPrivate Sub <\/span>C_TIMER01_TimerEvent()\r\n Me.LB01.Caption = Format(Now, \"dd mm yyyy hh:nn:ss\")\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2026_01\/pic_498_001.png\")
<\/p>\nTimer ohne Formular<\/h2>\n