Hi,
eigentlich ist die Realisierung recht einfach.
1. Du schreibst in einer .NET-Sprache (z.B. VB.NET) ein Klassenbibliotheks-Projekt.
2. Die in der COM-Welt sichtbare Klasse versiehst Du mindestens mit einer GUID und dem ComVisible-Attribut.
3. Das Bibliotheks-Projekt kennzeichnest Du mit "Make assembly COM-Visible".
4. Zielplattform ist als X86 zu setzen.
5. Die erzeugte dll ist dann im System zu registrieren (automatisch oder mit RegAsm.exe -tlb -codebase mydll.dll)
Viel wichtiger ist die Programmlogik. Die aufgerufene Methode der .NET-dll wird synchron abgearbeitet. Wenn Du dort eine asynchrone Arbeit starten willst, dann ist wichtig festzulegen, wie das Ende der asynchronen Arbeit auf das Hauptprogramm wirken soll.
Da die Übergabe von Objekten aus Access zur Nutzung in der .NET-dll nur Probleme bringen kann, sollte eine Art von Aufgaben in eine "Warteschlange" in der Access-Anwendung eingereiht werden. Die Warteschlange könnte z.B. eine temporäre Access-Tabelle
sein. Mit einem Aufruf einer Methode in der .NET-dll wird dann ein asynchroner Prozess zur Verarbeitung eines Warteschlangeneintrages gestartet. In der .NET-dll wird ohne Rücksicht auf die Access-Anwendung ein eigener Zugriff auf die Access-Datenbank organisiert.
Das bedeutet, dass zwei konkurrierende Anwendungen auf die Datenbank zugreifen, was in der Logik zu berücksichtigen ist. Dieser Ablauf entspricht logisch in etwa dem Beitrag von Markus.
Hier mal ein Gerüst für eine Lösung. Es wird in VB.NET eine Start-Methode aufgerufen, der im Beispiel ein Parameter übergeben wird, dann ein Thread gestartet und über ein Ereignis wird das Ende gemeldet.
Imports System.Runtime.InteropServices
<ComVisible(False)>
Public Delegate Sub SomeEventHandler(response As String)
<Guid("032F0C1E-3AD1-4BF7-A4BC-37769EC4560D"),
InterfaceType(ComInterfaceType.InterfaceIsIDispatch)>
Public Interface ComClass1Interface
<DispId(1)> Sub Start(msg As String)
End Interface
<Guid("55139E66-AD7D-4387-9E39-9117FBB34009"),
ComVisible(True),
InterfaceType(ComInterfaceType.InterfaceIsIDispatch)>
Public Interface IComClass1Events
<DispId(2)> Sub SomeEvent(response As String)
End Interface
<Guid("53CC5ACE-712F-4BDA-9B72-503C42F99F99"),
ComVisible(True), ClassInterface(ClassInterfaceType.None),
ComSourceInterfaces(GetType(IComClass1Events))>
Public Class ComClass1
Implements ComClass1Interface
Public Event SomeEvent As SomeEventHandler
Public Sub Start(msg As String) Implements ComClass1Interface.Start
Dim c As New ThreadClass With {.Message = msg}
AddHandler c.ThreadEnde, AddressOf StartEnde
Dim th As New Threading.Thread(New Threading.ThreadStart(AddressOf c.Execute))
th.Start()
End Sub
Private Sub StartEnde(response As String)
RaiseEvent SomeEvent(response)
End Sub
End Class
Friend Class ThreadClass
Friend Event ThreadEnde As SomeEventHandler
Friend Property Message As String
Friend Sub Execute()
Threading.Thread.Sleep(5000) ' Verzögerung der Arbeit simulieren
RaiseEvent ThreadEnde($"{Date.Now.ToLongTimeString} {Message}")
End Sub
End Class
Der Prinzipaufruf in VB6 (z.B. im Access-VBA) sieht dann so aus:
Public WithEvents obj As ComClass1
Sub Execute()
Set obj = New ComClass1
obj.Start "Los geht's " & Now
End Sub
Private Sub obj_SomeEvent(ByVal response As String)
MsgBox response
End Sub
--
Viele Grüsse
Peter Fleischer (ehem. MVP)
Meine Homepage mit Tipps und Tricks
