Beliebige Klasse instanzieren

[amoibos]

Hallo,
ich habe wenig gegoogelt aber mangels der richtigen Begriffe bin ich zu keiner Lösung gekommen. Der Anwendungsfall schildert sich wie folgt:

Ich hab ein Interface welche beliebige Implementierungen zulässt. Nun will ich an einer anderen Stelle einer Methode(Funktion) den Klassennamen übergeben(Implementierungen des Interfaces), damit darin das passende Objekt erzeugt wird. Dieses Objekt besitzt eine Methode dessen Rückgabewert ich dann weiterreichen würde.

Ein wenig Fachtermini wäre sicher nützlich um die Suche zu erleichtern und um das später selbst umzusetzen.

Danke für die Aufmerksamkeit.

[Uwe Raabe]

Bei XE7 kannst du ein Interface direkt auf ein TObject casten und dort über ClassName die implementierende Klasse abfragen.

Delphi-Quellcode:

var
  intf: IMyInterface;
  implClassName: string;
begin
  implClassName := TObject(intf).ClassName;
end;

[amoibos]

Ich steht gerade auf den Schlauch weil ich nicht weiß worauf du hinauswillst.
Wenn ich den Konstruktor aufrufe muss das Objekt nicht gecastet werden nach der Implementierung?

[Uwe Raabe]

Zitat von amoibos:

Ich steht gerade auf den Schlauch weil ich nicht weiß worauf du hinauswillst.

Vielleicht gilt das ja auch umgekehrt? Ich hatte es so verstanden, daß du aus einer Interface-Instanz den Namen der Implementierenden Klasse ermitteln willst. Offenbar ist das aber nicht so.

Wenn natürliche Sprache nicht das erforderliche Verständnis für ein Problem vermittelt, versuch es doch mal mit etwas Code. Was willst du eigentlich erreichen?

[Mavarik]

Du suchst eine Interface -> ObjectFactory!

[DualCoreCpu]

@Uwe Raabe: Ich frage da mal, ab welcher Delphi Version das mit dem Typecast von TObject auch Interface überhaupt klappt.

Der TE weiß nicht was Du überhaupt gemeint hast, laut Angabe in seinem Beitrag hat er Delphi 5. Wenn der Typecast wirklich erst ab Delphi XE klappt, kann der TE das Feature mit dem Typecast nicht nutzen mit Delphi 5. Auch ich nicht ich habe Delphi 7 und Turbo Delphi (2006).

Mich interessiert die Frage aber auch weil ich demnächst eine Freepascal Klassensammlung nach Delphi portieren will. Da will ich mir die frustrierende Schritt für Schritt Übersetzung mit Delphi und dioe aufwendige Quellcodeanpassung sparen und auch auf Interfaces setzen, die dann dieselben öffentlichen Mthoden haben wie die Fpc Klassen.

Da ergibt sich aber die zweite Frage. Normalerweise sind die Getter und Setter in den Klassen private. Im Interface müssen die aber public sein, wie die Eigenschaften (properties) die von den Gettern und Settern gelesen und geschrieben werden. Gibt es da einen Workaround, der mir erspart, die Getter und Setter in den Fpc Klassen alle public zu setzen?

Ich versteh die Frage von @amoibos so das er Klassen hat, die er per Interface ansprechen will. So wie ich, der ich Klassen aus Freepascal auch in Delphi nutzen will, mir aber gerne die aufwendige Quellcodeanpassung ersparen will, stattdessen will ich eine DLL bauen, in der die Klassendefinition, direkt oder als eingebundene Unit mit der Klasse und das zugehörige Interface steht. Auf der Delphi Seite hab ich dann nur das Interface. Die Implementation der Klasse befindet sich in der Dll. Nun will die Klasse in Delphi verwenden. In genau diesem Sinne versthe ich auch @amoibos Frage. Nun muss ja dem Interface mitgeteilt werden, auf welche Klassenimplementierung sich das Interface beziehen soll. Ich will dann das Interface anstelle der Klasse nutzen und das genauso, als ob ich die Fpc Klasse portiert hätte. Tprocess aus Lazarus ist so eine überaus sinnvolle Komponente, wenn ich von meiner Anwendung aus ein externes Programm aufrufen will. Es gibt noch einige andere, die es für Delphi so nicht gibt.

[amoibos]

Die klassische Factory ist ja statisch in dem Sinne, dass mir zur Laufzeit alle Implementierungen bekannt sein müssen, damit ich nach Typ unterscheiden kann. Das brauch und wollte ich eigentlich nicht. Ich will offen sein.

[Sir Rufo]

Zitat von DualCoreCpu:

Da ergibt sich aber die zweite Frage. Normalerweise sind die Getter und Setter in den Klassen private. Im Interface müssen die aber public sein, wie die Eigenschaften (properties) die von den Gettern und Settern gelesen und geschrieben werden. Gibt es da einen Workaround, der mir erspart, die Getter und Setter in den Fpc Klassen alle public zu setzen?

Ist das wirklich so in FPC?
In Delphi können die Methoden für das Interface stehen wo sie wollen.

Delphi-Quellcode:

type
  IFoo = interface
    procedure bar1;
    procedure bar2;
    procedure bar3;
  end;

  TFooImplementor = class( TInterfacedObject, IFoo )
  private
    procedure bar1; // es ist
  protected
    procedure bar2; // einfach
  public
    procedure bar3; // völlig egal
  end;

[Mavarik]

Zitat von amoibos:

Die klassische Factory ist ja statisch in dem Sinne, dass mir zur Laufzeit alle Implementierungen bekannt sein müssen, damit ich nach Typ unterscheiden kann. Das brauch und wollte ich eigentlich nicht. Ich will offen sein.

Naja der Typ muss schon bekannt sein...
Jedenfalls zum Zeitpunkt wo Du eine Instance erzeugen willst...

Die Instance muss nicht bekannt sein in der Unit von der Du das Aufrufst...

Normalerweise nimmt man für sowas ein Dictionary und Registriert daran die Implementationen... Mit dem TypeInfo...

Aber ein Beispiel ohne alles...:

Delphi-Quellcode:

program Project97;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type
   MyInterface = interface
     Function FooCalc(Const AValue : Integer) : Integer;
   end;

   TImpl1 = Class(TInterfacedObject,MyInterface)
     private
       Function FooCalc(Const AValue : Integer) : Integer;
   end;

   TImpl2 = Class(TInterfacedObject,MyInterface)
     private
       Function FooCalc(Const AValue : Integer) : Integer;
   end;

{ TImpl1 }

function TImpl1.FooCalc(const AValue: Integer): Integer;
begin
  Result := AValue * 2;
end;

{ TImpl2 }

function TImpl2.FooCalc(const AValue: Integer): Integer;
begin
  Result := AValue - 10;
end;

Function GetFoo(Const AName : String;Const AValue : Integer):Integer;
var
  IFooCalc : MyInterface;
begin
  if AName = 'Impl1' // Normalerweise Implementation aus Dictionary holen...
    then IFooCalc := TImpl1.Create
    else IFooCalc := TImpl2.Create;

  Result := IFooCalc.FooCalc(AValue);
end;

begin
  try
    { TODO -oUser -cConsole Main : Code hier einfügen }
    Writeln('Interface "Factory"');
    Writeln('Die Frage aller Fragen ...');
    Writeln('FooCalc1 1 mit 21 = '+ Inttostr(GetFoo('Impl1',21))); // Implementation nicht bekannt...
    Writeln('FooCalc1 2 mit 52 = '+ Inttostr(GetFoo('Impl2',52)));
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

[DualCoreCpu]

Zitat von Mavarik:

Du suchst eine Interface -> ObjectFactory!

Habe jetzt gerade eben diesen ganz spontan diesen Link dazu gefunden:

http://docs.oracle.com/javase/7/docs...ctFactory.html

Ich glaub, das isses.

Muss das in Delphi selber gebaut werden oder gibt es da schon irgendwo was? Letzteres hoffentlich nicht erst in den Delphi Versionen nach 2006.

Zitat von amoibos:

Die klassische Factory ist ja statisch in dem Sinne, dass mir zur Laufzeit alle Implementierungen bekannt sein müssen, damit ich nach Typ unterscheiden kann. Das brauch und wollte ich eigentlich nicht. Ich will offen sein.

Willkommen im Club, ich suche ähnliches für die Nutzung von Freepascal Klassen in Delphi.

Guck mal den o.g. Link an. Ob dort die implemetierte Klasse auch dymamisch zugeordnet werden kann, lese ich aber so schnell dort jetzt nicht raus. Werde morgen mich intensiver damit beschäftigen.

Vielleicht lässt sich da auch eine auf die eigenen verwendeten Klassen spezialisierte Object Factory bauen. Werd ich ab morgen sehen, ob das geht. Und ob das mit vertretbarem Aufwand geht.

Hoffe aber immer noch, das es da irgendwas in Delphi schon eingebautes gibt, auch in den älteren Versionen.

[EDIT]

Klar, TInterfacedObject!!! Wär noch die Frage das Aufbaus der Dll mit der implemtierten Klasse(n). Und der Interface Unit. Aber da schau ich mir erst mal Plugin Quelltexte an in denen auch sowas gemacht wird.

.