AW: Umgang mit Interfaces
Zitat:
Mutet zwar im Jahr 2013 etwas komsich an, aber irgendwie muss man seinen Kopf ja auch trainieren :spin: |
AW: Umgang mit Interfaces
Zitat:
Delphi-Quellcode:
unit Unit2;
interface uses Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, System.Generics.Collections, Vcl.StdCtrls; type IBase = Interface(IUnknown) function GetCanSave : Boolean; end; IValue = Interface(IBase) function GetIsNaN : Boolean; End; IInteger = Interface(IValue) function GetValue : Integer; procedure SetValue(const AValue : Integer); End; ICompare = Interface(IBase) function Compare : Boolean; End; ISomeThing = Interface(IBase) function DoSomeThing : Integer; End; TMyBase = Class(TInterfacedObject, IBase) public function GetCanSave : Boolean; End; TMyInteger = Class(TMyBase, IInteger) public function GetValue : Integer; procedure SetValue(const AValue : Integer); function GetIsNaN : Boolean; End; TMyCompare = Class(TMyBase, ICompare) public function Compare : Boolean; End; TMyDoSomething = Class(TMyCompare, IInteger, ISomeThing) public function DoSomeThing : Integer; function GetValue : Integer; procedure SetValue(const AValue : Integer); function GetIsNaN : Boolean; End; TForm2 = class(TForm) Button1 : TButton; procedure FormCreate(Sender : TObject); procedure Button1Click(Sender : TObject); private { Private declarations } fList : TDictionary<string, IBase>; public { Public declarations } end; var Form2 : TForm2; implementation {$R *.dfm} { TMyCompare } function TMyCompare.Compare : Boolean; begin end; { TMyInteger } function TMyInteger.GetIsNaN : Boolean; begin // end; function TMyInteger.GetValue : Integer; begin // end; procedure TMyInteger.SetValue(const AValue : Integer); begin // end; { TMyDoSomething } function TMyDoSomething.DoSomeThing : Integer; begin // end; function TMyDoSomething.GetIsNaN : Boolean; begin // end; function TMyDoSomething.GetValue : Integer; begin // end; procedure TMyDoSomething.SetValue(const AValue : Integer); begin // end; { TMyBase } function TMyBase.GetCanSave : Boolean; begin // end; procedure TForm2.FormCreate(Sender : TObject); begin fList := TDictionary<string, IBase>.Create; fList.Add(TMyInteger.ClassName , TMyInteger.Create); fList.Add(TMyCompare.ClassName , TMyCompare.Create); fList.Add(TMyDoSomething.ClassName , TMyDoSomething.Create); end; procedure TForm2.Button1Click(Sender : TObject); var MyObject : IBase; begin if fList.TryGetValue(TMyDoSomething.ClassName, MyObject) then begin IInteger(MyObject).SetValue(1); ISomeThing(MyObject).DoSomeThing; end; if fList.TryGetValue(TMyInteger.ClassName, MyObject) then begin IInteger(MyObject).SetValue(2); end; if fList.TryGetValue(TMyCompare.ClassName, MyObject) then begin ICompare(MyObject).Compare; end; end; end. |
AW: Umgang mit Interfaces
Zitat:
Aber, sobald von einem "referenzzählenden" Objekt eine Interface-Referenz "erzeugt" wurde, dann übernimmt die Referenzzählung die Kontrolle über die Speicherverwaltung. Sobald dann die letzte Referenz weg ist, wird das Objekt freigegeben und dein Objektzeiger wird ungültig. Ohne Interfacereferenzen bleibt die Speicherfreigabe dem .Free überlassen. Darum war auch mein Tipp: Wenn mit "referenzzählenden" Interfaces gearbeitet werden soll, dann möglichst durchgehend nur noch mit Interface-Referenzen arbeiten und wenn Objekt-Referenzen nötig sind, dann muß man dort eben aufpassen. |
AW: Umgang mit Interfaces
Zitat:
|
AW: Umgang mit Interfaces
Ja ich weiß - Das Teil ist sein Geld wirklich mehr als wert.
Nach dem letzten Einkauf (TChart Pro) will ich vorerst nicht schon wieder laut nach weiteren Investitionen schreien ;-) Vorerst |
AW: Umgang mit Interfaces
Zitat:
Die Get-Funktion wird dann zu:
Delphi-Quellcode:
wobei das Resultat auf IInterface-Support eingeschränkt wird(?). Da man aber Supports nicht ohne eine IID_xxx aufzurufen kann, muss man hier wieder ein konkretes Interface angeben. Also etwa:
function TMyList.Get<T>(const AIndex: Integer): T;
begin if not Supports(FList[AIndex].fMy, Result) then //<- Error Result := nil; end;
Delphi-Quellcode:
Womit eigentlich nur mehr das IBase-Interface von der Funktion zu haben wäre? Ausprobieren konnte ich das ganze nicht, denn obwohl sich der Code der Liste compilieren lässt, bekomme ich dann bei einem Zugriffsversuch vom Compiler die Meldung: "E2531 Methode 'Get' erfordert explizite Typargumente", was eventuell daran liegt, dass ich keinen korrekten Aufruf hinbekommen habe..
function TMyList.Get<T>(const AIndex: Integer): T;
begin if not Supports(FList[AIndex].fMy, IID_BASE, Result) then Result := nil; end;
Code:
i: IBase;
i := fMyList.Get(0); i := fMyList.Get(0) As IBase; ... Wünschen würde ich mir ja eher sowas wie:
Delphi-Quellcode:
Unabhängig von der korrekten Implementierung frage ich mich auch noch wie die Performanz hier aussieht. Es werden ja ständig Interfaces über Strings gesucht?
Var
iSom: ISomeThing; iInt: IInteger; begin for i := 0 To fMyList.Count-1 Do begin if fMyList.Get(i, iInt) Then iInt.SetValue(Random(100)); if fMyList.Get(0, iSom) Then iSom.DoSomething; .. |
AW: Umgang mit Interfaces
Zitat:
Delphi-Quellcode:
Wobei IID hier auch direkt ein Interface-Typ sein kann (IMyFunnyInterface, IInteger, IDoSomeThing).
function Supports(const Instance: IInterface; const IID: TGUID; out Intf): Boolean;
function Supports(const Instance: TObject; const IID: TGUID; out Intf): Boolean; function Supports(const Instance: IInterface; const IID: TGUID): Boolean; function Supports(const Instance: TObject; const IID: TGUID): Boolean; function Supports(const AClass: TClass; const IID: TGUID): Boolean; Codebeispiel anhand deines Falls:
Delphi-Quellcode:
type
TMyDoSomething = Class(TMyCompare, IInteger, ISomeThing) ... end; var MySomeThingObject : ISomeThing; begin MySomeThingObject := TMyDoSomething.Create; if Supports(MySomeThingObject, IInteger) then begin ShowMessage('IInteger wird voll unterstützt!!!'); end; end; |
AW: Umgang mit Interfaces
Zitat:
Edit: Habe nicht erwähnt das ich meine Klassen nicht als Interface speichern kann (ISomeThing muss zu TSomeThing werden), weil ich eben eine "Basisliste" mit allen Klassen habe. Diese stehen untereinander in verschiedenen Beziehungen und pflegen daher eigene TNodeList-en um eine Referenz auf diese benötigten Instanzen zu haben. Durch diese Verlinkung schnellt der _RefCount bei verwendung von Interfaces aber hoch und am Programmende, wenn die "Basisliste"-alles frei gibt, bleibt ein riesiges Memoryleek über. |
AW: Umgang mit Interfaces
Zitat:
Dann solltest du die Referenzzählung auf jeden Fall in allen Objekten deaktivieren. Es macht keinerlei Sinn die zu nutzen, wenn du nicht durchgängig mit Interfaces arbeitest. Das haben wir als Notlösung bei der Umstellung in alten Quelltexten vorübergehend auch gemacht, sind aber mittlerweile so weit, dass wir es größtenteils richtig, sprich nur mit Interfaces, umgesetzt haben. Das ist bei Verwendung von Interfaces ja die einzige sinnvolle Variante. |
AW: Umgang mit Interfaces
Zitat:
Delphi-Quellcode:
aufrufst, bevor du es in deine Liste speicherst. Damit sagst du der Referenzzählung ja, dass da noch eine Referenz ist. Bevor du die Klasse dann freigibst musst du diese Referenz dann wieder mit
_AddRef
Delphi-Quellcode:
lösen und wenn keine andere Referenz auf eines der Interfaces der Klasse vorhanden ist, sollte sie auch gleich automatisch freigegeben werden. :?
_Release
Gruß, Sven |
Alle Zeitangaben in WEZ +1. Es ist jetzt 23:09 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz