COM-Klasse lässt keine Properties zu?

  • VB.NET

Es gibt 5 Antworten in diesem Thema. Der letzte Beitrag () ist von Higlav.

    COM-Klasse lässt keine Properties zu?

    Hallo liebe Community,

    Da ich schon einige Monate mit VB.NET programmiere, will ich nicht mehr auf all die Möglichkeiten des .NET-Frameworks verzichten, wenn ich in Excel-VBA code. Aus diesem Grund nahm ich mir vor, eine COM-Klasse zu schreiben, die einige wichtige und nützliche Klassen aus dem Framework beinhaltet. Bis jetzt klappt es.

    Jedoch, als ich sie testen wollte, und es sich bei der getesteten Klasse um eine zu instanzierende Klasse (z.B. IO.FileInfo) mit Properties handelte, bekam ich folgenden Fehler:
    Objekterstellung durch ActiveX-Komponente nicht möglich


    Ich hab' wie im Tipp beschrieben im Konstruktor keine Paramter verlangt. Die holte ich dann über eine Klasseneigene Prozedur. Und genau an diesem Punkt meckert Excel rum :(
    Ich wollte fragen, ob es eine Möglichkeit gibt, in COM-Klassen mit Properties zu arbeiten, da ich die statischen Methoden der IO.File-Klasse micht wirklich mag und die Instanzierung doch sehr angenehm zuhandhaben ist.

    Ich hab' das Ganze mit dieser Klasse ausprobiert

    VB.NET-Quellcode

    1. <ComClass(Versuch.ClassId, Versuch.InterfaceId, Versuch.EventsId)> Public Class Versuch
    2. Public Const ClassId As String = "819f1953-1dee-4c4e-b1d6-e4580a11cf7d"
    3. Public Const InterfaceId As String = "90982013-e8a8-4d5b-8fb8-4165b2530c56"
    4. Public Const EventsId As String = "d36565fc-d501-4ac8-896b-c1c0da60f9bf"
    6. Private _Str As String
    8. Public Property Str As String
    9. Get
    10. Return _Str
    11. End Get
    12. Set(value As String)
    13. _Str = value
    14. End Set
    15. End Property
    17. Public Sub New()
    18. MyBase.New()
    19. End Sub
    21. Public Sub Eintragen(Str As String)
    22. _Str = Str
    23. End Sub
    25. End Class

    Und mit diesem Code in Excel getestet

    VB.NET-Quellcode

    1. Option Explicit
    3. Sub los()
    5. Dim Vers As New NETSystem.Versuch
    6. Vers.Eintragen "Hallo" '<-- Der Fehler kommt hier
    7. MsgBox Vers.Str
    9. End Sub


    Grüsse

    Higlav

    Edit:
    Ich hab' gestern noch ein wenig herumprobiert.
    Anscheinend funktioniert auch die Instanzierung von Objekten in der Klasse nicht.

    Ich wollte mit meiner COM-Klasse eigentlich die Funktionsweise einiger meiner VBA-Skripte beträchtlich erhöhen, aber mit so starken Einschränkungen hab' ich nicht gerechnet... :(

    Edit by hal2000:
    - Posts zusammengefügt.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „hal2000“ () aus folgendem Grund: Titel war falsch gewählt

    Wichtig bei COM, die Assembly muss signiert sein (sn.exe) und mit regasm registriert werden.

    Versuchs mal so:

    VB.NET-Quellcode

    1. Dim Vers As NETSystem.Versuch
    2. Set Vers = New NETSystem.Versuch
    3. Call Vers.Eintragen("Hallo")
    4. MsgBox Vers.Str
    SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

    Weil einfach, einfach zu einfach ist! :D

    Hallo BiedermannS,

    Ich hatte schon einen Signierungsschlüssel im Projekt erstellt("Eigenschaften" -> "Signierung") und ein Häckchen bei "für COM-Interop registrieren" wie auch in den Assemblyinformationen eines bei "Assembly COM-sichtbar machen" gesetzt. Ich denke, somit muss ich die Klasse nicht noch mit RegAsm.exe oder sn.exe weiterbehandeln. (?)
    Es scheint, als würde nur schon das Erstellen des Objektes misslingen (bis auf die Initialisierung der Variable), denn nun stoppt der Debugger schon beim Setzen der Variable auf die neue Instanz der Klasse. (bei Set Vers = New NETSystem.Versuch)
    Mir scheint, als ob es nicht ("nur") am internen Erstellen von Objekten, sondern allgemein etwas in meiner Klasse nicht so hinhaut, wie es sollte... :S

    Grüsse

    Higlav

    Hier ist ein sehr lesenswerter Artikel über COM-Interop: codeproject.com/Articles/990/U…-Interoperability-With-NE

    ...ist aber nichts für schwache Nerven. Man sollte sich vorab schon ein wenig mit der Materie auskennen.

    Ich habe ein wenig Erfahrung damit, also habe ich mal ein Beispiel geschrieben (ist kommentiert, inklusive Vorgehensweise):
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Runtime.InteropServices
    3. 'Projekt: Klassenbibliothek, .NET 4, Name = VbaDLL
    4. 'Assembly COM-sichtbar machen: Nein
    5. 'Assembly für Interop registrieren: Nein
    6. 'Assembly signieren (neuen Key in den Projekteigenschaften erstellen, kein Passwort)
    7. 'als x86 erstellen (!)
    9. 'Visual Studio-Eingabeaufforderung als Administrator:
    10. 'Nach bin/x86/Release navigieren
    11. 'tlbexp VbaDLL.dll
    12. 'regasm /tlb:VbaDLL.tlb VbaDLL.dll
    13. 'gacutil /i VbaDLL.dll
    15. 'rückgängig (--> wieder sauberes System) mit:
    16. 'gacutil /u VbaDLL <-- OHNE .dll
    17. 'regasm /u /tlb:VbaDLL.tlb VbaDLL.dll
    19. 'Excel:
    20. 'Verweis auf VbaDLL setzen
    22. 'Das Interface ist standardmäßig dual, also IUnknown und IDispatch.
    23. 'Das ist die IID in der Registry (Extras --> GUID generieren)
    24. <Guid("F791D6E9-CBB2-441b-A57C-ABB549991F22")> _
    25. <ComVisible(True)> _
    26. Public Interface IFrameworkWrapper
    27. 'mehrere Beispiele für Funktionen, Properties, etc.
    28. Property ValueX As Int32 'X-Wert
    29. Sub SetY(y As Int32) 'Y-Wert
    30. Function Add() As Int32 'Addition, Ergebnis als Rückgabewert
    31. Sub Subtract() 'Subtraktion, Ergbnis in ReadOnly SubResult
    32. ReadOnly Property SubResult As Int32
    33. 'Division + Modulo, Argumente als Parameter, Ergebnis als Parameter (x DIV y) und Rückgabewert (x MOD y)
    34. Function DivMod(x As Int32, y As Int32, ByRef quotient As Int32) As Int32
    35. 'beliebiger String
    36. Property MyString As String
    37. Sub Eintragen(s As String)
    38. End Interface
    40. 'Das ist die CLSID in der Registry (Extras --> GUID generieren)
    41. <Guid("C5637559-C50A-44dd-8DD3-0E91E6F030ED")> _
    42. <ClassInterface(ClassInterfaceType.None)> _
    43. <ComVisible(True)> _
    44. Public Class FrameworkWrapper
    45. Implements IFrameworkWrapper
    47. Private m_x As Int32
    48. Private m_y As Int32
    49. Private m_res As Int32
    50. Private m_str As String
    52. Public Function Add() As Integer Implements IFrameworkWrapper.Add
    53. Return m_x + m_y
    54. End Function
    56. Public Function DivMod(x As Integer, y As Integer, ByRef quotient As Integer) As Integer Implements IFrameworkWrapper.DivMod
    57. quotient = x \ y
    58. Return x Mod y
    59. End Function
    61. Public Sub SetY(y As Integer) Implements IFrameworkWrapper.SetY
    62. m_y = y
    63. End Sub
    65. Public ReadOnly Property SubResult As Integer Implements IFrameworkWrapper.SubResult
    66. Get
    67. Return m_res
    68. End Get
    69. End Property
    71. Public Sub Subtract() Implements IFrameworkWrapper.Subtract
    72. m_res = m_x - m_y
    73. End Sub
    75. Public Property ValueX As Integer Implements IFrameworkWrapper.ValueX
    76. Get
    77. Return m_x
    78. End Get
    79. Set(value As Integer)
    80. m_x = value
    81. End Set
    82. End Property
    84. Public Sub Eintragen(s As String) Implements IFrameworkWrapper.Eintragen
    85. m_str = s
    86. End Sub
    88. Public Property MyString As String Implements IFrameworkWrapper.MyString
    89. Get
    90. Return m_str
    91. End Get
    92. Set(value As String)
    93. m_str = value
    94. End Set
    95. End Property
    96. End Class

    Testcode (Office Excel 2003, Button "TuWas"):
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Sub TuWas_BeiKlick()
    2. Dim dotnet As VbaDLL.FrameworkWrapper
    3. Set dotnet = New VbaDLL.FrameworkWrapper
    5. dotnet.ValueX = 11
    6. dotnet.SetY 3
    8. MsgBox "x is " & dotnet.ValueX
    9. MsgBox "x + y = " & dotnet.Add
    11. Call dotnet.Subtract
    12. MsgBox "x - y = " & dotnet.SubResult
    14. Dim rDiv As Long
    15. Dim rMod As Long
    16. rMod = dotnet.DivMod(11, 3, rDiv)
    18. MsgBox "11 DIV 3 = " & rDiv & ", 11 MOD 3 = " & rMod
    20. dotnet.Eintragen "Hallo Welt"
    21. MsgBox "DotNET String: " & dotnet.MyString
    22. dotnet.MyString = "anderer String"
    23. MsgBox "DotNET String: " & dotnet.MyString
    25. End Sub

    Dieser Code funktioniert bei mir wie erwartet. Ganz wichtig ist das explizite Erstellen als x86, denn Office ist immer noch ein 32-Bit-Programm und kann daher keine 64-Bit-DLLs laden. Letztere werden aber generiert, wenn AnyCPU eingestellt ist. Das wird auch der Grund für den Fehler sein, den du oben kassiert hast.

    Debuggen kann man dieses Gebilde auch - man setzt in VB.NET einfach ein Debugger.Break() in die Funktion, führt sie aus und wartet auf den so simulierten Absturz. Der JIT-Debugger erledigt den Rest und hält in der .NET-Funktion an.

    Du kannst bei regasm /codebase setzen - dann musst du beim Neuerstellen nicht immer das gacutil bemühen. Erstelle am besten eine Batch-Datei für das Neuregistrieren der DLL.
    Gruß
    hal2000

    Hallo hal2000,

    Danke für die umfangreiche Antwort.:thumbsup: Ich werd' mir das alles mal in Ruhe ansehen.

    Grüsse

    Higlav

Facebook
Telefonspende