DLL einbinden, in Klasse oder global

[himitsu]

@uligerhardt: auch einen Class-Procedur hat diesen versteckten Parameter Namens Self.

@General: Nein, nur wenn man sie auch zusätzlich noch als statisch deklariert

[uligerhardt]

Zitat von Neutral General:

Ist eine class function nicht sowieso immer statisch?

Nö, es gibt virtuelle Klassenmethoden:

Delphi-Quellcode:

type
  TBaseClass = class of TBase;

  TBase = class
    class procedure Bla; virtual;
  end;

  TDerived = class(TBase)
    class procedure Bla; override;
  end;

implementation

{ TBase }

class procedure TBase.Bla;
begin
  Writeln('TBase.Bla');
end;

{ TDerived }

class procedure TDerived.Bla;
begin
  Writeln('TDerived.Bla');
end;

Delphi-Quellcode:

var
  c: TBaseClass;
begin
  c := TDerived;
  c.Bla;
end;

Dazu wird der implizite Self-Pointer benötigt, den das static entfernt. Das Schlüsselwort wurde für Kompatibilität mit .NET eingeführt, weil das nur die Variante ohne Self beherrscht.

[uligerhardt]

Zitat von himitsu:

@uligerhardt: auch einen Class-Procedur hat diesen versteckten Parameter Namens Self.

Nur, wenn sie kein static hintendran hat.

[sirius]

Bevor ihr hier solche Verrenkungen macht:
In folgendem Beispiel kann sich so eine Klasse erst lohnen:

Delphi-Quellcode:

unit Unit2;

interface

uses Windows, Sysutils;

type

  IPS7Exception = class(Exception);

  IPS7Open=function(IPAdr : PChar; Rack : LongWord; Slot : LongWord; RxTimeout : LongWord; TxTimeout : LongWord ; ConnectTimeout : LongWord) : LongInt; stdcall;

  TIPS7 = class
    Constructor Create;
    Destructor Destroy; override;
   private
    FDLL:THandle;
    FIPS7Open:IPS7Open;
    FConnectTimeout: LongWord;
    FRack: LongWord;
    FSlot: LongWord;
    FRxTimeOut: Longword;
    FTxTimeout: LongWord;
    FIPAdr: AnsiString;
    procedure SetConnectTimeout(const Value: LongWord);
    procedure SetIPAdr(const Value: AnsiString);
    procedure SetRack(const Value: LongWord);
    procedure SetRxTimeOut(const Value: Longword);
    procedure SetSlot(const Value: LongWord);
    procedure SetTxTimeout(const Value: LongWord);
   public
    property IPAdr:AnsiString read FIPAdr write SetIPAdr;
    property Rack :LongWord read FRack write SetRack;
    property Slot :LongWord read FSlot write SetSlot;
    property RxTimeOut:Longword read FRxTimeOut write SetRxTimeOut;
    property TxTimeout:LongWord read FTxTimeout write SetTxTimeout;
    property ConnectTimeout:LongWord read FConnectTimeout write SetConnectTimeout;
    function Open:Longword;
  end;




implementation

const
  spsDll = 'IPS7LNK.DLL';


{ TIPS7 }

constructor TIPS7.Create;
begin
  FDLL:=Loadlibrary(spsDLL);
  if FDLL=0 then
    raise IPS7Exception.CreateFmt('Fehler beim Laden der DLL: %s',
      [syserrormessage(getlasterror)]);
  FIPS7Open:=GetProcAddress(FDLL,'IPS7Open');
  if not assigned(FIPS7Open) then
    raise IPS7Exception.CreateFmt('Fehler beim LAden der Funktionsadresse: %s',
      [syserrormessage(getlasterror)]);
end;

destructor TIPS7.Destroy;
begin
  FreeLibrary(FDLL);
  inherited;
end;

function TIPS7.Open: Longword;
begin
  result:=FIPS7Open(PAnsiChar(FIPAdr),FRack,FSlot,FRxTimeout,
    FTxTimeout,FConnectTimeout);
end;

procedure TIPS7.SetConnectTimeout(const Value: LongWord);
begin
  FConnectTimeout := Value;
end;

procedure TIPS7.SetIPAdr(const Value: String);
begin
  FIPAdr := Value;
end;

procedure TIPS7.SetRack(const Value: LongWord);
begin
  FRack := Value;
end;

procedure TIPS7.SetRxTimeOut(const Value: Longword);
begin
  FRxTimeOut := Value;
end;

procedure TIPS7.SetSlot(const Value: LongWord);
begin
  FSlot := Value;
end;

procedure TIPS7.SetTxTimeout(const Value: LongWord);
begin
  FTxTimeout := Value;
end;

end.

Damit hat man auch gleich einen Container für die Parameter und kann hier noch weitere Funktionen kapseln. Bringt natürlich nur etwas, wenn man diesen Container auch benötigt.
Zudem habe ich DLL noch dynamisch eingebunden. Dadurch führt ein Fehlen der DLL nicht gleich zum Nichtstarten des Programms. Bringt auch nur etwas, wenn das Programm auch ohne diese DLL einen Sinn macht.

[shmia]

So, wie es Sirius gezeigt hat isses richtig!

Vielleicht noch zwei kleine Kritikpunkte bzw. Verbesserungen:
1.) Die Open-Funktion gibt ein Handle (Referenz) zurück.
Dieses Handle sollte im Objekt gespeichert werden und beim Freigeben des Objekts wird dann automatisch die Close-Funktion aufgerufen.
Das Handle braucht der Anwender der Klasse wahrscheinlich gar nie zu Gesicht bekommen;
das vereinfacht den Umgang mit der Klasse.
2.) Man könnte den Code in zwei Klassen splitten:
Eine Klasse (Name: TIPS7_DLL) ist zuständig für das DLL-Handle und die Funktionszeiger in die DLL.
Die andere Klasse (Name: TIPS7) stellt sozusagen eine Verbindung zur S7 dar.
Der Anwender sieht nur die Klasse TIPS7.
Intern verwendet TIPS7 ein Objekt der Klasse TIPS7_DLL (als Singleton implementiert) um die DLL-Funktionen aufzurufen.