alle Methoden eines Servers feststellen

[Knut Lambert]

Hallo zusammen!

Ich habe ein EXE file, welches einen COM Server beinhaltet. Eine TLB liegt nicht vor und nach Registrierung kann ich keine Interfaces finden.
Mit OleView komme ich nicht weiter.

Die mir bekannten Methoden kann ich einwandfrei nutzen. Mich würde interessieren, welche Eigenschaften und Methoden vom Server insgesamte zur Verfügung gestellt werden. Kann mir jemand sagen, wie ich das Problem angehen muss?

mfg

Knut

[Andreas Kosch]

Hallo,

wenn der COM-Server nur das <b>IDispatch</b>-Interface unterstützt, hat man da keine Change, denn die Methoden werden nur über den Namen als Zeichenkette (!) aufgerufen. Erst der COM-Server entscheidet zur Laufzeit, ob eine derartige Methode bekannt ist.

Das folgende Beispiel zeigt, was dabei im Hintergrund abläuft. Die entscheidende Stelle verbirgt sich hinter der IDispatch-Methode <b>GetIDsOfNames</b>:

<pre>

{ ************************************************** **************
Source File Name : InvokeDemoFrm.pas
Typ : Formular-Unit
Autor : Andreas Kosch
Erstellt am : 23.05.1998
Compiler : Delphi 3.02 / 4.02
Betriebssystem : Windows 95 / 98
Beschreibung : Beispiel für das klassische Disp-Interface
Revisionen : 14.11.1998 Test mit Delphi 4
************************************************** ************** }

unit InvokeDemoFrm;

interface

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

type
TFormMain = class(TForm)
StatBar: TStatusBar;
ButtonGetIDsOfNames: TButton;
ButtonInvoke: TButton;
StaticTextDispID: TStaticText;
ButtonWordStart: TButton;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
procedure ButtonWordStartClick(Sender: TObject);
procedure ButtonGetIDsOfNamesClick(Sender: TObject);
procedure ButtonInvokeClick(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;

var
FormMain: TFormMain;

implementation

{$R *.DFM}

uses
ActiveX, ComObj;

var
pDisp : IDispatch;
sPropName : Widestring;
iDispId : TDispId;

procedure TFormMain.ButtonWordStartClick(Sender: TObject);
begin
pDisp := CreateOleObject('Word.Application');
ButtonGetIDsOfNames.Enabled := True;
ButtonWordStart.Enabled := False;
end;

procedure TFormMain.ButtonGetIDsOfNamesClick(Sender: TObject);
begin
sPropName := 'Visible';
OleCheck(pDisp.GetIDsOfNames (GUID_NULL, @sPropName, 1,
LOCALE_SYSTEM_DEFAULT, @iDispId));
StaticTextDispID.Caption := Format('Visible = %d', [iDispId]);
ButtonInvoke.Enabled := True;
end;

procedure TFormMain.ButtonInvokeClick(Sender: TObject);
var
vSet : OLEVariant;
aDispParams : TDispParams;
aDispId : TDispId;
aEI : TExcepInfo;
iError : UINT;
begin
vSet := True;
FillChar(aDispParams, SizeOf (aDispParams), 0);
with aDispParams do begin
rgvarg := @vSet;
cArgs := 1;
cNamedArgs := 1;
end;
aDispId := DISPID_PROPERTYPUT;
aDispParams.rgdispidNamedArgs := @aDispId;
OleCheck (pDisp.Invoke (iDispId, GUID_NULL, LOCALE_SYSTEM_DEFAULT,
DISPATCH_PROPERTYPUT, aDispParams, NIL, @aEI, @iError));
end;

end.

</pre&gt

[Bernhard Geyer]

Ich denke folgender Code sollte alle Properties/Methoden eines Interfaces zurückliefern können (Hatte auch mal ein solches Problem):

<pre>
{: Liefert entweder alle Funktionen oder all Variablen der Schnittstelle zurück
@PARAM Dispatch zu untersuchende Schnittstelle
@PARAM Entries Stringlist, die Schnittstelleneinträge beinhaltet
@PARAM Functions False = Properties werden abgefragt
True = Methoden werden abgefragt
}
procedure EnumInterface(Dispatch: IDispatch; Entries: TStrings; Functions: Boolean);
var
TypeInfo: ITypeInfo;
TypeAttr: PTypeAttr;
FuncDesc: PFuncDesc;
Vardesc: PVarDesc;
hr: HResult;
iMethode: Integer;
nNames : integer;
sNameLst: TBSTRList;
begin
Dispatch.GetTypeInfoCount(iMethode);

if iMethode > 0 then
begin
hr := Dispatch.GetTypeInfo(0,GetUserDefaultLCID,TypeInfo );
OleCheck(hr);
hr := TypeInfo.GetTypeAttr(TypeAttr);
OleCheck(hr);

if Functions then
begin
for iMethode := 0 to TypeAttr.cFuncs-1 do
begin
hr := TypeInfo.GetFuncDesc(iMethode, FuncDesc);
OleCheck(hr);
hr := TypeInfo.GetNames(FuncDesc.memid, @sNameLst,1,nNames);
OleCheck(hr);
Entries.Add(Format('%d %s', [FuncDesc.memid, sNameLst[0]]));
// Namen aus erstem Eintrag sNameLst auslesen
// Anzahl Argumente := FuncDesc.cParams
end;
end
else
begin
for iMethode := 0 to TypeAttr.cVars-1 do
begin
hr := TypeInfo.GetVarDesc(iMethode, Vardesc);
OleCheck(hr);
hr := TypeInfo.GetNames(Vardesc.memid, @sNameLst,1,nNames);
OleCheck(hr);
Entries.Add(Format('%d %s', [Vardesc.memid, sNameLst[0]]));
end;
end;
end;
end;
</pre&gt

[Knut Lambert]

Danke für die Kommentare! Habe beides mal umgesetzt und auf den Server angewendet.

Es scheint so zu sein, dass, wie schon von Herrn Kosch vermutet, nur das IDispatch Interface unterstützt wird. Ich kann mit
GetIDsOfNames die IDs aller mir bekannten Funktionen und Eigenschaften feststellen. Mit der Methode GetTypeInfoCount erhalte ich eine 0.

Da die Liste der bekannten IDs Lücken aufweißt, regt das natürlich meine Neugierde an, kippt dann aber von der Wirtschaftlichkeit zum akademischen Spiel. Ist wohl mehr ein Thema für die nächsten Feiertage.

Noch einmal Danke und bis später

Knu

[Andreas Kosch]

Hallo,

das ITypeInfo-Interface kann nur die Daten zurückliefern, die vom COM-Server "freundlicherweise" zur Verfügung gestellt werden. Wenn der COM-Server keine Typbibliothek zur Verfügung stellt, hat der Anbieter von diesem Teil vermutlich etwas gegen eine allzu freizügige Mitnutzung :-