COM Objects
Zoals ik in de introduktie al aangaf: COM staat voor Component Object Model, en met behulp van COM kunnen we objecten bouwen (en gebruiken) die draaien in een Windows omgeving, en volledige ontwikkelomgeving of programmeertaal onafhankelijk zijn. Ik kan dus in Delphi een COM object bouwen en dat in Visual Basic of C++ gebruiken (en andersom). In dit artikel zal ik mij beperken tot bouwen en gebruiken vanuit Delphi zelf - raadpleeg de documentatie behorende bij je eigen favoriete Windows ontwikkelomgeving voor de mogelijkheden tot het importeren en gebruiken van deze COM objecten.

Nieuw COM Object
Om met een eenvoudig voorbeeld te beginnen, gaan we een nieuw generiek COM Object maken met Delphi 6 (straks zal blijken dat er nog meer "speciale" COM mogelijkheden zijn, zoals een Automation Object, een Transactional Object of een Activer Server Object). Start Delphi 6, en sluit het default project (dat willen we niet gebruiken). Doe nu File | New - Other en ga naar de ActiveX tab van de Object Repository.

  library Euro42;
  uses
    ComServ;

  exports
    DllGetClassObject,
    DllCanUnloadNow,
    DllRegisterServer,
    DllUnregisterServer;

  {$R *.RES}

  begin
  end.

  unit Euro;
  {$WARN SYMBOL_PLATFORM OFF}
  interface
  uses
    Windows, ActiveX, Classes, ComObj, Euro42_TLB, StdVcl;
  
  type
    TEuro = class(TTypedComObject, IEuro)
    protected
    end;
  
  implementation
  uses
    ComServ;
  
  initialization
    TTypedComObjectFactory.Create(ComServer, TEuro, Class_Euro,
      ciMultiInstance, tmApartment);
  end.

Type Library Editor
Behalve de nieuwe unit, krijgen we ook meteen de Type Library Editor te zien. Dit is de plek om nieuwe properties en methoden toe te voegen aan het COM Object - of specifieker gezegd, aan het IEuro interface. De Type Library kan gezien worden als de definitie van onze COM Objecten - letterlijk het interface met o.a. de properties en methoden, die met behulp van de Type Library Editor op eenvoudige wijze aan te passen en te onderhouden zijn. De Type Library zelf heeft de naam van het project en de extentie .tlb, en de import unit is Euro42_TLB.pas (dit bestand wordt iedere keer opnieuw gegenereerd nadat we een wijziging in de type library hebben gemaakt, dus het is over het algemeen niet zinvol om zelf wijzigingen in de type library import unit te maken).

  type
    TEuro = class(TTypedComObject, IEuro)
    protected
      function EuroNaarGulden(Euro: Double; out Gulden: Double): HResult; stdcall;
    end;

  function TEuro.EuroNaarGulden(Euro: Double; out Gulden: Double): HResult;
  begin
    Gulden := Euro * 2.20371; // implementatie
  end;

  function TEuro.EuroNaarGulden(Euro: Double; out Gulden: Double): HResult;
  begin
    Gulden := Euro * 2.20371; // implementatie
    Result := S_OK
  end;

Nu kunnen we ons Euro42 project compileren, maar nog niet draaien, omdat het een DLL is en geen executable. COM Objecten worden gebruikt door zogenaamde COM Clients, en die gaan we nu bouwen.

Register COM Objects
Maar voordat we een COM Client gaan bouwen, moeten we eerst de COM Server gaan registreren. Dat kan met behulp van de Run | Register ActiveX Server menu optie. Hierdoor zijn meteen alle COM objecten in de Euro42.dll geregistreerd voor gebruik.

COM Objecten gebruiken
Een COM Client kan zo'n beetje elk denkbaar Delphi project zijn, dus start maar een gewone nieuwe applicatie. Bewaar het main form in MainForm.pas en het project in EuroClient.dpr. We moeten nu zowel de ComObj unit als de Euro42_TLB.pas (type library import unit) aan de uses clause toevoegen, zodat het IEuro interface bekend is en gebruikt kan worden. Om het gebruik te demonstreren hebben we verder twee TEdits en een TButton nodig. Geef de TEdits de namen edtEuro en edtGulden, en de TButton de naam btnConvert. De code voor de OnClick event handler van de btnConvert is als volgt:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    Euro: IEuro;
    Gulden: Double;
  begin
    Euro := CreateCOMObject(Class_Euro) as IEuro;
    Euro.EuroNaarGulden(StrToFloatDef(edtEuro.Text,0),Gulden);
    edtGulden.Text := Format('hfl. %.2f',[Gulden])
  end;

Hoe zat dat nou met S_OK?
Eerder vertelde ik dat de EuroNaarGulden methode eigenlijk een funktie was die een HResult waarde teruggeeft - in ons geval altijd S_OK. Maar wat moeten we eigenlijk doen met deze HResult waarde? Welnu, het is "good practice" om iedere COM methode (die een HResult waarde teruggeeft) aan te roepen binnen een speciale wrapper genaamd OleCheck. Die controleert het resultaat, en als dat niet S_OK is krijgen we een foutmelding. Om toch maar netjes COM te gebruiken, zouden we dus de implementatie van de OnClick event handler als volgt kunnen herschrijven:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    Euro: IEuro;
    Gulden: Double;
  begin
    Euro := CreateCOMObject(Class_Euro) as IEuro;
    OleCheck(Euro.EuroNaarGulden(StrToFloatDef(edtEuro.Text,0),Gulden));
    edtGulden.Text := Format('hfl. %.2f',[Gulden])
  end;

Automation
Een Automation object is een speciaal COM object - het speciale zal straks duidelijk worden (nb: voor de meeste COM ontwikkelaars is een automation object het "gewone" scenario en een COM object het bijzondere geval - zie weer een van de artikelen van Peter van Ooijen voor details). We kunnen een nieuw automation object gewoon toevoegen aan onze bestaande Euro42 ActiveX Library (er kunnen meerdere COM objecten in dezelfde DLL opgenomen worden), met File | New - Other, en dan van de ActiveX tab het Automation Object icon. Dit geeft de volgende dialoog, die lijkt op die van een "normaal" COM Object:

Nieuwe methoden
Laten we eerst nog even twee methoden toevoegen. Dat gaat weer met behulp van de Type Library Editor net als met de vorige IEuro interface. Deze keer noem ik de methoden EuroToGuilder en GuilderToEuro, en geef ze wederom twee argumenten mee (het tweede argument weer van type "out"), die deze keer echter van type Currency zijn. De implementatie van EuroToGuilder en GuilderToEuro zal niet zo'n verrassing zijn denk ik:

  const
    GuilderPerEuro = 2.20371;

  procedure TAutoEuro.EuroToGuilder(Euro: Currency; out Guilder: Currency);
  begin
    Guilder := Euro * GuilderPerEuro
  end;

  procedure TAutoEuro.GuilderToEuro(Guilder: Currency; out Euro: Currency);
  begin
    Euro := Guilder / GuilderPerEuro
  end;

Automation Objecten gebruiken
En nu komen we bij een interessant deel van het artikel: waar we "normale" COM Objecten slechts op één manier kunnen gebruiken (met CreateCOMObject), daar kunnen we Automation Objecten op drie verschillende manieren gebruken, via variants (het meest flexibel, maar ook "gevaarlijkste"), via dispinterfaces, en tot slot via interfaces (de manier van de normale COM Objecten).

Variants (dispatch interfaces)
Waarom zouden we eigenlijk variants willen gebruiken? De belangrijkste reden is gemak. Variants maken gebruik van "late binding" om de methoden van het Automation Object aan te roepen. Ze hoeven dus niet tijdens compilatie al te weten welke methoden en argumenten beschikbaar (en geldig) zijn, maar zoeken dit tijdens het draaien wel uit. Helaas betekent dit ook dat er geen Code Insight ondersteuning meer is. Met alle gevolgen van dien als iemand een tikfoutje gemaakt heeft, want de methode EuroToGulden bestaat echt niet. Het voordeel is dat we geen Type Library import unit nodig hebben, en dat we ieder Automation Object op onze machine op deze manier kunnen benaderen (waaronder bijvoorbeeld de Office onderdelen), wat op z'n tijd best handig is. Voor het gebruik van de AutoEuro via Variants, is de code als volgt:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    Euro: Variant;
    Guilder: Currency;
  begin

    Euro := CreateOleObject(EuroClassName)

    Euro.EuroToGuilder(StrToFloat(edtEuro.Text),Guilder); // GEEN Code Insight!!
    edtGuilder.Text := FloatToStr(Guilder)
  end;

Dispinterfaces
Een stapje "hoger" (en sneller) is het gebruik van dispinterfaces. Ook hierbij wordt late binding gebruikt. Echter, er is wel Code Insight ondersteuning aanwezig, dus we kunnen toch de aanwezige methoden en hun argumenten zien. Dat komt omdat het dispinterface alle methoden (en argumenten) definieert, zodat we hieruit kunnen kiezen. Op het moment dat de methoden worden aangeroepen, wordt via late binding het dispatch iD gebruikt om de juiste methode te vinden en aan te roepen. Er is geen GetIDsOfNames meer nodig (want het ID kennen we al), dus dit werkt niet alleen handiger (met Code Insight) dan de Variants oplossing, maar ook sneller. De code voor het gebruik van AutoEuro via dispinterfaces is als volgt:

  procedure TForm1.Button2Click(Sender: TObject);
  var
    Euro: IEuro42Disp;
    Guilder: Currency;
  begin
    Euro := CoEuro42.Create as IEuro42Disp;
    Euro.EuroToGuilder(StrToFloat(edtEuro.Text),Guilder); // WEL Code Insight!!
    edtGuilder.Text := FloatToStr(Guilder)
  end;

Interfaces
Het laatste voorbeeld maakt gebruik van de "normale" interfaces en early-binding zoals we die eerder zagen voor het IEuro object. De code voor het gebruik is hierbij als volgt:

  procedure TForm1.Button3Click(Sender: TObject);
  var
    Euro: IEuro42;
    Guilder: Currency;
  begin
    Euro := CoEuro42.Create;
    Euro.EuroToGuilder(StrToFloat(edtEuro.Text),Guilder); // WEL Code Insight!!
    edtGuilder.Text := FloatToStr(Guilder)
  end;