c# DLL .NET in DELPHI32 nutzen

[hgiel]

Hallo,

ich habe ein dokumentierte .NET-DLL, die ich in DELPHI 7 unter Win32 nutzen möchte:

Sie liegt als COM-Wrapper??? bzw. als .Net Assembly ??? vor:

1) meinedll.COM.dll
2) meiendll.COM.tlb
3) meinedll.dll

In der Doku wird von Namensräumen und ihren Eigenschaften gesprochen!

Ich habe keine Ahnung wie ich diese DLLs einbinden und dann nutzen kann ;-((

Um das konkret zu machen:

Ein Namensraum lautet "Version" und besitzt die Eigenschaft "Major" Typ: int

Ich würde nun gerne den Zugriff testen, in dem ich per ButtonClick diese Eigenschaft auslese und als inttostr(Version.Major????) in einem Edit-Feld anzeige!

[sirius]

Wenn ein COM-Wrapper vorliegt, und dieser das ist, was ich vermute, würde ich mich unter Delphi32 mal ganz schnell darauf (also auf die xxx.COM.DLL) stürzen.

Versuch doch mal die TypBibliothek zu importieren (irgendwo im Delphi-Menu)!

[rweinzierl]

Hallo


Dot.Net Dlls unterscheiden sich grundsätzlich von normalen Delphi bzw. C++ DLL's aus der WIN32 Welt.

Bei einer Win32.dll stellt die DLL einen Satz an funktionen bereit die im Prenzip von jeder Sprache aus aufgerufen werden können.

Bei einer C# DLL funktiert ganz anders.
Dort liegen die Funkionen als vorkopmpilierter Quellcode vor und benötigen unbedingt die Dot.Net Runtime.

==> Ein normaler Aufruf aus Delphi ist (fast) unmöglich.

Der Standard Weg den Microsoft empfiehlt ist der Umweg über .COM ( bzw AcitveX)
( Hat halt den Nachteil das alles wieder durch die Registry muss!)

Im Internet findet man auch eine Methode die dot.net Runtime komplett in den eigenen Prozess zu laden, und von dort aus die c# DLL wieder anzusprechen ==> Ist aber (meiner Meinung nach) nur etwas für absolute Experten.

Als Bastellösung kann man noch eine Anwendung in c# schreiben ( diese kann die DLL ohne Probleme Laden), und kommuniziert über eine selber ausgedachte Schnittstelle (Socket, Named Pipes, Mapped Memory ....)

von Remobjects gibts ein Produkt names Hydra, auch damit sollte so etwas möglich sein ( noch nicht getestet)

==> An einer besseren Veriante wäre auch ich interessiert.

mfg

Reinhold Weinzierl

[hgiel]

Hallo,

vielen Dank für die Infos

ich habe die COM.TLB überdie Typbibliothek importiert und auch eine entsprechende UNIT erzeugt, die ich nun in das Programm unter USES impementiert habe:

Ausschnitt aus der NEUEN LIB-Unit:

Delphi-Quellcode:

interface

uses Windows, ActiveX, Classes, Graphics, mscorlib_TLB, OleServer, StdVCL, Variants;
  


// *********************************************************************//
// In dieser Typbibliothek deklarierte GUIDS . Es werden folgende         
// Präfixe verwendet:                                                     
//   Typbibliotheken     : LIBID_xxxx                                     
//   CoClasses           : CLASS_xxxx                                     
//   DISPInterfaces      : DIID_xxxx                                      
//   Nicht-DISP-Schnittstellen: IID_xxxx                                       
// *********************************************************************//
const
  // Haupt- und Nebenversionen der Typbibliothek
  Sts_Db_SiZ_Usb_ComMajorVersion = 1;
  Sts_Db_SiZ_Usb_ComMinorVersion = 0;

  LIBID_Sts_Db_SiZ_Usb_Com: TGUID = '{9D632297-83A7-3DCC-80D1-65E37EE18965}';

  IID_ISiZUsbCOM: TGUID = '{18CD27C2-3EDD-48D0-A2F5-2A7FB2C8E6A5}';
  IID__SiZUsbCOM: TGUID = '{E3C6DF0A-23D3-38D1-810A-ED6BA2C8C241}';
  CLASS_SiZUsbCOM: TGUID = '{FBE6DA18-7BC9-4671-83F9-8D477D3DC39B}';
type

// *********************************************************************//
// Forward-Deklaration von in der Typbibliothek definierten Typen         
// *********************************************************************//
  ISiZUsbCOM = interface;
  ISiZUsbCOMDisp = dispinterface;
  _SiZUsbCOM = interface;
  _SiZUsbCOMDisp = dispinterface;

// *********************************************************************//
// Deklaration von in der Typbibliothek definierten CoClasses             
// (HINWEIS: Hier wird jede CoClass zu ihrer Standardschnittstelle        
// zugewiesen)                                                            
// *********************************************************************//
  SiZUsbCOM = _SiZUsbCOM;


// *********************************************************************//
// Schnittstelle: ISiZUsbCOM
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {18CD27C2-3EDD-48D0-A2F5-2A7FB2C8E6A5}
// *********************************************************************//
  ISiZUsbCOM = interface(IDispatch)
    ['{18CD27C2-3EDD-48D0-A2F5-2A7FB2C8E6A5}']
    function Get_Version_Major: Integer; safecall;
    function Get_Version_Minor: Integer; safecall;
    function Get_Version_Build: Integer; safecall;


....


Leider kann ich noch nicht auf die Funktionen - z.B. Get_Version_Major - aus der Bibliothek zugreifen:

Fehler "Ungenügende Forward oder external - Deklaration"!!!

Ausschnitt aus meinem Programm:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Sts_Db_SiZ_Usb_Com_TLB;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

function Get_Version_Major: Integer; safecall;

implementation

{$R *.dfm}


procedure TForm1.Button1Click(Sender: TObject);
begin
  showmessage(inttostr(Get_Version_Major));
end;

...

Wahrscheinlich habe ich nur ein Brett vorm Kopf und der Zugriff ist ganz leicht zu bewerkstelligen???

[edit=SirThornberry]Delphi-Tags gesetzt - nächstes mal bitte selbst machen! - Mfg, SirThornberry[/edit]

[Alter Mann]

Hi,

Entschuldigung: Schon mal mit Interfaces oder ActieX programmiert?

In der Unit einen

Delphi-Quellcode:

initialization
  CoInitialize(nil);

finalization
  CoUninitialize;

schreiben, dann sollte es auch mit dem TLB-Import Funktionieren.

[sirius]

Zitat:

Zitat von Alter Mann

Hi,

Entschuldigung: Schon mal mit Interfaces oder ActieX programmiert?

In der Unit einen

Delphi-Quellcode:

initialization
  CoInitialize(nil);

finalization
  CoUninitialize;

schreiben, dann sollte es auch mit dem TLB-Import Funktionieren.

Solange die TLB eingebunden ist, ist das für den MainThread bereits erledigt.


Aber mit Interfaces umgehen, musst du noch lernen.
Also (nur eine mögliche Variante):

1. Du bindest die TLB unter Uses ein (wenn es nicht schon der Fall ist)
2. Du definierst dir eine Variable vom benötigten Interface (bspw: var myIntf:ISiZUsbCOM)
3. Du initialisierst an gegebener Stelle das Interface mit Hilfe der CoClass (bsp: myIntf:=coSiZUsbCOM.create
4. jetzt rufst du die Funktionen auf (myIntf.get_major_version)

Alles andere lässt du erstmal weg. Das wie gesagt nur ein Weg, die TLB bietet auch noch mehr Möglichkeiten. Nebenbei: Das Interface wird automatisch freigegeben, brauchst du dich nicht darum kümmern.

[hgiel]

Hallo,

vielen Dank für den Input - es ist wahr ich muss mich wirklich mal intensiver um INTERFACE-Prog kümmern ;-(

Die Hinweise von Sirius haben mir insofern geholfen, dass ich nunmehr immerhin schon mal die Funktionen, Properties - rein vom Codevervollständiger - sehen und "nutzen" kann.

Leider gibt es noch eine Fehlermeldung: Klasse nicht registriert! bzw. eine Zugriffsverletzung...!

Hier mal mein Code zum gucken und ausserdem habe ich auch die DLL-Unit mit rangehängt:

unit Unit1;

Delphi-Quellcode:

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Sts_Db_SiZ_Usb_Com_TLB;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

  myIntf1: _SiZUsbCOM; //Interface

  myIntf2: ISizUsbCOM; //Interface *

//  myIntf3: _SiZUsbCOMDisp; //DispInterface - Warnungshinweis plattformspezifisch

//  myIntf4: ISizUsbCOMDisp; //DispInterface - Warnungshinweis plattformspezifisch

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);

begin
  myIntf1:=coSiZUsbCOM.create; // -> Fehlermeldung Klasse nicht registriert!
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  testzahl: integer;
begin
  testzahl:= myIntf2.Version_Major; // -> Fehlermeldung Zugriffsverletzung
  showmessage(inttostr(testzahl));
  if myIntf2.TrueCryptExists then showmessage('JA') else showmessage('Nein'); // -> hier auch Fehlermeldung Zugriffsverletzung
end;

end.

[edit=SirThornberry]Delphi-Tags gesetzt - nächstes mal bitte selbst machen - Mfg, SirThornberry[/edit]

[sirius]

Du hast auch soweit alles richtig gemacht. Bis auf, das du globale Variablen definiert hast (myIntfx). Nimm die doch bitte in eine Klasse (zB. zu TForm1 unter private Deklarationen)
Und noch dazu:

Zitat:

Fehlermeldung Klasse nicht registriert!

Tja, sieht so aus, als hättest du die Klasse noch nicht registriert in deinem System. (siehe regsvr32; was normalerweise eine Installation macht)

[EDE]

Hallo Leute,

ich muss mich hier mal anhängen. :-D

Seit geraumer zeit bin ich SecondLife verfallen und such eine möglichkeit die libsecondlife.dll in die Win32welt von Delphi zu bekommen.

libsecondlife.dll ist in C# für .Net gecodet und OpenSource. Guggst du hier

Alles was passiert das mir Delphi2007 beim Importieren von .Net eine mscorlib_TLB.pas erstellt und sich aufhängt. :(

Ich habe es auch mit Delphi2006 versucht das kann aber kein .Net 2.0

Wenn jemand Rat weis oder vieleicht es schon gemacht hat wer einfach super.

Besten Dank schon mal im Vorraus

[gvita]

Hallo also mann kann aus manged code eine dll erzeugen mit der auch nicht .net sprachen arbeiten können als ob es eine normale dll wäre.

Guck mal

http://www.codeproject.com/KB/dotnet/DllExport.aspx

Gruß

[SirThornberry]

@EDE: Erstelle dafür bitte ein eigenes Thema :-)

[r_kerber]

Sodele, dann will ich diesen alten Fred noch mal an's Tageslicht holen. Zunächst ein Ausschnit aus der TLB:

Delphi-Quellcode:

interface

uses Windows, ActiveX, Classes, Graphics, mscorlib_TLB, OleServer, StdVCL, System_TLB, 
System_Windows_Forms_TLB, Variants;
  

// *********************************************************************//
// In dieser Typbibliothek deklarierte GUIDS . Es werden folgende         
// Präfixe verwendet:                                                     
//   Typbibliotheken     : LIBID_xxxx                                     
//   CoClasses           : CLASS_xxxx                                     
//   DISPInterfaces      : DIID_xxxx                                      
//   Nicht-DISP-Schnittstellen: IID_xxxx                                       
// *********************************************************************//
const
  // Haupt- und Nebenversionen der Typbibliothek
  CoffeeBarMajorVersion = 1;
  CoffeeBarMinorVersion = 0;

  LIBID_CoffeeBar: TGUID = '{139F5D3F-8DE9-4FCE-9923-B6BA49633642}';

  DIID_ICoffeeBarControllerEvents: TGUID = '{EAACEE53-949A-4696-96A7-1EF7C5D31369}';
  IID_ICup: TGUID = '{84845D18-CCF1-46C1-AAD9-6DEF0DDDE05E}';
  IID_ICoffeeBarController: TGUID = '{4C47A0AB-BE53-47CA-B885-A4D4C55E7A98}';
  IID__CoffeeBarController: TGUID = '{A547F46B-C929-3AEC-8D50-D947AE1E32B3}';
  CLASS_CoffeeBar_: TGUID = '{E09C9B19-B865-4CB2-B4A3-3F7E986DCC7A}';
  CLASS_Cup: TGUID = '{E37A70DA-74B2-4CB7-8020-F8E4CE7DBA3D}';
  CLASS_Bean: TGUID = '{F0818ED3-7E04-4F74-827D-F7F7033D7DAF}';
  CLASS_CoffeeBarController: TGUID = '{40921CDF-5944-4E8A-9873-10F92450E7F9}';
type

// *********************************************************************//
// Forward-Deklaration von in der Typbibliothek definierten Typen         
// *********************************************************************//
  ICoffeeBarControllerEvents = dispinterface;
  ICup = interface;
  ICupDisp = dispinterface;
  ICoffeeBarController = interface;
  ICoffeeBarControllerDisp = dispinterface;
  _CoffeeBarController = interface;
  _CoffeeBarControllerDisp = dispinterface;

// *********************************************************************//
// Deklaration von in der Typbibliothek definierten CoClasses             
// (HINWEIS: Hier wird jede CoClass zu ihrer Standardschnittstelle        
// zugewiesen)                                                            
// *********************************************************************//
  Cup = ICup;
  Bean = _Object;
  CoffeeBarController = _CoffeeBarController;


// *********************************************************************//
// DispIntf:  ICoffeeBarControllerEvents
// Flags:     (4096) Dispatchable
// GUID:      {EAACEE53-949A-4696-96A7-1EF7C5D31369}
// *********************************************************************//
  ICoffeeBarControllerEvents = dispinterface
    ['{EAACEE53-949A-4696-96A7-1EF7C5D31369}']
    procedure Brewed(const ticket: WideString); dispid 1;
  end;

// *********************************************************************//
// Schnittstelle: ICup
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {84845D18-CCF1-46C1-AAD9-6DEF0DDDE05E}
// *********************************************************************//
  ICup = interface(IDispatch)
    ['{84845D18-CCF1-46C1-AAD9-6DEF0DDDE05E}']
    function Taste: WideString; safecall;
    function Get_BeansUsed: WideString; safecall;
    property BeansUsed: WideString read Get_BeansUsed;
  end;

// *********************************************************************//
// DispIntf:  ICupDisp
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {84845D18-CCF1-46C1-AAD9-6DEF0DDDE05E}
// *********************************************************************//
  ICupDisp = dispinterface
    ['{84845D18-CCF1-46C1-AAD9-6DEF0DDDE05E}']
    function Taste: WideString; dispid 1610743808;
    property BeansUsed: WideString readonly dispid 1610743809;
  end;

// *********************************************************************//
// Schnittstelle: ICoffeeBarController
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {4C47A0AB-BE53-47CA-B885-A4D4C55E7A98}
// *********************************************************************//
  ICoffeeBarController = interface(IDispatch)
    ['{4C47A0AB-BE53-47CA-B885-A4D4C55E7A98}']
    procedure OpenCoffeeBar; safecall;
    procedure CloseCoffeeBar; safecall;
    procedure AddBean(const beanName: WideString); safecall;
    procedure BrewCoffee(const beanName: WideString); safecall;
    function GetOrderedCup(const ticket: WideString): ICup; safecall;
    function Get_ServedCoffees: Integer; safecall;
    property ServedCoffees: Integer read Get_ServedCoffees;
  end;

// *********************************************************************//
// DispIntf:  ICoffeeBarControllerDisp
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {4C47A0AB-BE53-47CA-B885-A4D4C55E7A98}
// *********************************************************************//
  ICoffeeBarControllerDisp = dispinterface
    ['{4C47A0AB-BE53-47CA-B885-A4D4C55E7A98}']
    procedure OpenCoffeeBar; dispid 1610743808;
    procedure CloseCoffeeBar; dispid 1610743809;
    procedure AddBean(const beanName: WideString); dispid 1610743810;
    procedure BrewCoffee(const beanName: WideString); dispid 1610743811;
    function GetOrderedCup(const ticket: WideString): ICup; dispid 1610743812;
    property ServedCoffees: Integer readonly dispid 1610743813;
  end;

// *********************************************************************//
// Schnittstelle: _CoffeeBarController
// Flags:     (4432) Hidden Dual OleAutomation Dispatchable
// GUID:      {A547F46B-C929-3AEC-8D50-D947AE1E32B3}
// *********************************************************************//
  _CoffeeBarController = interface(IDispatch)
    ['{A547F46B-C929-3AEC-8D50-D947AE1E32B3}']
  end;
...

gefolgt von Code-Snippets, die den Zugriff auf dieses COM-Objekt zeigen sollen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  CoffeeBar: ICoffeeBarController;
  //  CoffeeBar2: TCoffeeBarController;
  Result: Integer;
begin
  CoffeeBar := CreateComObject(CLASS_CoffeeBarController) as ICoffeeBarController;
  CoffeeBar.AddBean('A');
  CoffeeBar.AddBean('B');
  CoffeeBar.AddBean('C');
  CoffeeBar.OpenCoffeeBar;
end;

Das funktioniert soweit schon ganz gut. jetzt stellt sich allerdings die Frage, wie man im Delphi-Programm das Event

Delphi-Quellcode:

  ICoffeeBarControllerEvents = dispinterface
    ['{EAACEE53-949A-4696-96A7-1EF7C5D31369}']
    procedure Brewed(const ticket: WideString); dispid 1;
  end;

abfangen kann

[ChrisE]

Hallo,

hast du in deiner TLB nicht auch noch irgendwo ne von TOleServer abgeleitet Wrapper-Klasse. Diese Kapselt das ganze doch wieder in eine Klasse mit den entsprechenden Methoden und Events.

Greez, Chris

[r_kerber]

Jep:

Delphi-Quellcode:

// *********************************************************************//
// OLE-Server-Proxy-Klassendeklaration
// Server-Objekt    : TCoffeeBarController
// Hilfe-String     : 
// Standardschnittstelle: _CoffeeBarController
// Def. Intf. DISP? : No
// Ereignisschnittstelle: ICoffeeBarControllerEvents
// TypeFlags        : (2) CanCreate
// *********************************************************************//
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
  TCoffeeBarControllerProperties= class;
{$ENDIF}
  TCoffeeBarController = class(TOleServer)
  private
    FOnBrewed: TCoffeeBarControllerBrewed;
    FIntf:        _CoffeeBarController;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
    FProps:       TCoffeeBarControllerProperties;
    function      GetServerProperties: TCoffeeBarControllerProperties;
{$ENDIF}
    function      GetDefaultInterface: _CoffeeBarController;
  protected
    procedure InitServerData; override;
    procedure InvokeEvent(DispID: TDispID; var Params: TVariantArray); override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
    procedure Connect; override;
    procedure ConnectTo(svrIntf: _CoffeeBarController);
    procedure Disconnect; override;
    property DefaultInterface: _CoffeeBarController read GetDefaultInterface;
  published
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
    property Server: TCoffeeBarControllerProperties read GetServerProperties;
{$ENDIF}
    property OnBrewed: TCoffeeBarControllerBrewed read FOnBrewed write FOnBrewed;
  end;

[ChrisE]

Gut :-)

Damit hast du ja dann alles was du brauchst :-)

Greez, Chris

[r_kerber]

Zitat:

Zitat von ChrisE (Beitrag 1034461)

Damit hast du ja dann alles was du brauchst :-)

Vor allem Verständnisschwierigkeiten. :duck:

[ChrisE]

Hallo,

einfach erstmal kurz vergessen, dass du ein Com-Klasse verwendest :-)

Eine Objekt-Instanz erstellen von TCoffeeBarController und an beliebiger Stelle erstellen bzw. Freigeben - wie halt immer bei Klassen ;-)

Dann kannst du dein Event vom Typ TCoffeeBarControllerBrewed in Form1 erstellen mit mit Leben befüllen.

Beim erstellen der Objectinstanz von CoffeBarController dein eigenes Event der Objektinstanz zuweisen per

Delphi-Quellcode:

MyCoffeeBarController.OnBrewed := MyBrewedEvent

. Wenn du auf das Interface zugreifen willst einfach per

Delphi-Quellcode:

MyCoffeeBarController.DefaultInterface.AddBean('a');

Ich hoffe, das Hilft.

Greez, Chris

[r_kerber]

Zitat:

Zitat von ChrisE (Beitrag 1034466)

Beim erstellen der Objectinstanz von CoffeBarController dein eigenes Event der Objektinstanz zuweisen per

Delphi-Quellcode:

MyCoffeeBarController.OnBrewed := MyBrewedEvent

Das funktioniert.

Zitat:

Zitat von ChrisE (Beitrag 1034466)

Wenn du auf das Interface zugreifen willst einfach per

Delphi-Quellcode:

MyCoffeeBarController.DefaultInterface.AddBean('a');

Das DefaultInterface hat leider keine Methode AddBean. Außerdem wird das Formular nicht sichtbar.

[ChrisE]

Hmmm,

jetzt sehe ich es auch erst. Irgendwie ist der OleServer nur für die Events zuständig nicht aber für den Rest :-( Bei meinen bisherigen COM-Objekten war das aber eigentlich immer so :-( Vor allem waren dort auch die entsprechenden Methoden direkt Implementiert. So musste man quasi gar nicht mehr auf das Interface zugreifen.

Sorry, das habe ich nicht gesehen. Dann weiß ich erstmal auch nicht weiter. Bräuchte die komplette TLB.

Greez, Chris

[r_kerber]

Habe die TLB.Pas mal angefügt

Nachtrag: IN VB6 geht's so...

Code:

Public WithEvents objCoffeeBarServant As CoffeeBar.CoffeeBarController
Public iCoffeeBarServant As CoffeeBar.ICoffeeBarController
...
Public Sub Form_Load()
   
    Set objCoffeeBarServant = New CoffeeBarController
    Set iCoffeeBarServant = objCoffeeBarServant
    ...  
    iCoffeeBarServant.AddBean ("Nicaragua")
    ...
    iCoffeeBarServant.OpenCoffeeBar
   
End Sub
...
Private Sub objCoffeeBarServant_Brewed(ByVal ticket As String)
       
    Dim orderedCupOfCoffee As ICup
    Set orderedCupOfCoffee = iCoffeeBarServant.GetOrderedCup(ticket)
    
    Text1.Text = orderedCupOfCoffee.Taste
    Text2.Text = iCoffeeBarServant.ServedCoffees
    
End Sub

[ChrisE]

Hallo,

ok, der Aufbau scheint hier einfach etwas anders zu sein, als ich es bisher kenne. Das VB6-Beispiel zeigt ja wie es geht.

Du nutzt die Klasse um Dein Event zu erhalten und holst dir das Interface ICoffeeBarController über die Klasse. Aber das hast du ja wahrscheinlich selber schon gesehen aus dem VB6 Beispiel :-)

Greez, Chris

[r_kerber]

Muss man für jetzt für jedes Event solch einen Aufwand betreiben? Ich habe das bisher eigentlichen auf die Unzulänglichkeiten in VB6 geschoben. Hatte eigentlich gehofft, dass man hier ähnliche arbeiten kann wie bei einem ActiveX-Control.

[ChrisE]

Soweit ich das jetzt überblicke, hast du ja nur ein Event :duck:

Aber es sieht schon so aus, als ob das alles so aufgeteilt ist und du dir über den Controller die entsprechenden Interfaces holen musst.

Greez, Chris

[r_kerber]

Zitat:

Zitat von ChrisE (Beitrag 1034889)

Soweit ich das jetzt überblicke, hast du ja nur ein Event :duck:

haha, ich lach später :-D Das ist doch nur 'ne Spielwiese zum Üben und Probieren. Später kommen dann massenweise Events (aus diversen noch zuerstellenden Formularen)...

Zitat:

Zitat von ChrisE (Beitrag 1034889)

Aber es sieht schon so aus, als ob das alles so aufgeteilt ist und du dir über den Controller die entsprechenden Interfaces holen musst.

Genau diesen Aufwand wollte ich eigentlich vermeiden...

[ChrisE]

Hallo,

ja, kann ich verstehen. Aber ich denke die Konstruktion der Interfaces und Klassen dieser Komponenten etc. werden Dir da keinen andere Möglichkeit lassen. Klar kannst du dir selber Wrapper-Klassen bauen, die das für die wieder auflösen und einfacher machen. Aber das ist halt genauso Handarbeit.
Leider habe ich auch nicht so viel mit den COM-Zeugs und OleServern etc. zu tun um dir da jetzt einen gangbaren Weg zu zeigen.

Vielleicht gibt es ja ein paar andere Cracks hier, die dir da weiter helfen können das zu vereinfachen.

Viel Erfolg noch.

Greez, Chris