Einige Methoden in mehreren Klassen verwenden?

[dizzy]

Ich muss um Verzeihung bitten, wenn meine Postings bisher etwas ...naja klangen. Das war eher locker flockig gemeint :). Ich denke ich habe das Problem an sich durchaus verstanden. Aber ich glaube ich weiss was mit zu obigem Schluss getrieben hat:

Zitat:

Zitat von Pseudemys Nelsoni

dann müsste ich ja jede Klasse die die Methoden braucht von dieser ableiten.... ich muss aber schon von TCLientSocket ableiten...

Anhand dieses Beispiels nahm ich an, dass du unterschiedliche Klassen erstellt, die alle und auch nur von TClientSocket erben, und nichts anderem. Sehe ich das richtig, dass TClientSocket nur ein Beispiel war? Wenn nicht, dann blicke ich noch immer wohl nicht voll durch.

Zitat:

Zitat von Pseudemys Nelsoni

In deinem Beispiel hätte TMainClass wie auch TClass1 nämlich von TClientSocket geerbt. Bloss brauch ich das in letzterer Klasse kaum.

Du musst von TClientSocket ableiten, brauchst das aber in einer tieferen Ableitung nicht mehr? Warum musst du dann erst überhaupt von TClientSocket ableiten? :gruebel:

Aber ich glaube etwas was man "generischen Vorfahrentyp" nennen könnte, wäre was du suchst oder? (Ist mir noch nie unter gekommen :))

[Pseudemys Nelsoni]

@ST: Ich versuchs mal, danke ;)

@dizzy

Zitat:

Du musst von TClientSocket ableiten, brauchst das aber in einer tieferen Ableitung nicht mehr? Warum musst du dann erst überhaupt von TClientSocket ableiten?

Vielleicht habe ich mich auch ein ewnig unverständlich ausgedrückt, wenn dem so ist, dann sorry ;)

Es ist nicht so das ich in einer tieferen ableitung keinen ClientSocket mehr brauche, denn ich leite nicht noch einmal von einer Klasse ab. Es geht darum das ich eine Klasse in 2 _verschiedenen_ Klassen benutzen kann.

Um nochmal mein Beispiel zu nennen:

Delphi-Quellcode:

TMethodClass = class(TObject) 
private 
  function func1: Integer; 
  function func2: Integer; 
  function func3: Integer; 
end;

Das wäre meine Methoden-Klasse die ich innerhalb einer Klasse brauche die bereits schon von TClientSocket ableitet:

Delphi-Quellcode:

TAnotherClass = class(TClientSocket)
end;

^^^^ in diese Klasse möchte ich nun aber auch noch von TMethodClass ableiten damit ich dessen Methoden benutzen kann.

So etwas wie:

Delphi-Quellcode:

TAnotherClass = class(TClientSocket, TMethodClass)
end;

Aber das geht wohl nicht...


Danke für deine Hilfe trotzdem ;)

[Fossibaer58809]

Hallo zusammen,

eventuell ergibt sich eine Lösung im Zusammenhang mit den oben erwähnten Interfaces, eben durch "Delegieren an eine Eigenschaft vom Typ einer Klasse" (siehe OH, mit Beispiel).

Gruß
Michael

[Hansa]

Zitat:

Zitat von Pseudemys Nelsoni

...Aber das geht wohl nicht...

So nicht. 8)

[Robert_G]

Ich wollte dir gerade einen kleinen Bleisitift basteln. Doch mein D7 fand es irgendwie cooler abzurauchen. :wall:

Ich habe dir noch ein klitzekleines Beispiel gefriemelt. Aus obengenanntem Abkacker ist mir die
Lust am Kommentieren vergangen. Die Bezeichner dürften aber, zusammen mit der minimalen Funktionalität ( :mrgreen: ), selbstklärend sein.

Im Endeffekt leiten alle Klassen von einem Vorfahren ab.
Spätere Ableitungen implementieren ein Interface durch das sie generisch behandelt werden können.

[Fossibaer58809]

Auch ich habe eben auf Grund meines Postings eine kleine Demoapp gebastelt.
Sie hängt hier dran.

Gruß
Michael

[dizzy]

Ich denke ich komme der Sache näher :D

Hatte gerad auch noch eine kleine Idee dazu, die aber (in meiner Version) voraussetzt, dass Parameterliste und evtl. Rückgabetyp der einzuerbenden Methoden alle gleich sind. Vielleicht lässt sich das ja auch noch umbasteln... Ist grad zu spät um da noch qualifiziert weiter zu denken :)

Hier mal was mir grad in den Sinn kam:

Delphi-Quellcode:

type
  TCFunc = function(a, b: Integer): Integer of object;

  TMethodClass = class
  public
    class function Add(a, b: Integer): Integer;
    class function Sub(a, b: Integer): Integer;
  end;

  TMyClass = class
  private
    FMethods: TMethodClass;
    function GetMethod(s: String): TCFunc;
  public
    property Method[s: String]: TCFunc read GetMethod; default;
  end;

implementation

{ TMethodClass }

class function TMethodClass.Add(a, b: Integer): Integer;
begin
  result := a+b;
end;

class function TMethodClass.Sub(a, b: Integer): Integer;
begin
  result := a-b;
end;

{ TMyClass }

function TMyClass.GetMethod(s: String): TCFunc;
begin
  if s = 'Add' then result := FMethods.Add
  else
  if s = 'Sub' then result := FMethods.Sub;
end;

// Anwendung

procedure TuWas;
var
  tmp: TMyClass;
  x: Integer;
begin
  tmp := TMyClass.Create;
  x := tmp.Method['Add'](2, 3);
  x := tmp.Method['Sub'](x, 5);
  // Leider klappt, trotz default-tag folgendes nicht:
  x := tmp['Add'](2, 3);
  x := tmp['Sub'](x, 5);
  // Der Compiler meckert, aber ich kann nicht nachvollziehen warum :\
  tmp.Free;
end;

end.

Naja, wollts nur nicht vorenthalten haben - evtl. lohnt es sich ja doch da weiter zu denken. :)


Gudde Nacht,
Fabian

[maximov]

Moin zusammen :)

Soweit ich das beurteilen kann - und das kann ich (AUS! Robert) - ist die lösung von Fossibaer58809 die, die der ausgangsfragestellung am nächsten kommt, wenn sie sie nicht sogar komplett erfüllt. Das gefrimel von robert und dizzy ist zwar cool, aber echt nicht so elegant wie diese delphi-'delegates'. *und.hopp.und.weg*

:thumb: Weiter so! Ich liebe solche threads, wo über elementares geredet wird und nicht über klickie-gelöt :mrgreen:

[Robert_G]

Jo, interface implementierende properties sind schon irgendwo cool. :)

In meinem Bleistift sollte die Property (Name) aber nur vom Besitzer der versteckten Instanz gehandhabt werden.
Es sollte ja kein Umdenken nötig werden um in späteren Ableitungen damit umzugehen. (Deshalb ja auch ein fixer RefCount von 1 ;) )
Genau da verlässt man IMHO die Möglichkeiten einer implementierenden property. :?

Wie gesagt, die Idee ist sau cool. Die Technik dahinter auch.
Ich denke dass wäre eine verflucht elegante Lösung gegen das leidige Problem der Typisierung/Generalisierung bei eigenen Collections. :)
Also wie es in .Net mit der expliziten Implementierung erfolgt. ;)

Code:

  void IList.Add(object value)
  {
     Add(MyItemType(value));
  }

  public void Add(MyItemType value)
  {
     ...
  }

Danke nochmal, gefällt mir immer mehr... :thuimb:

[maximov]

Zitat:

Zitat von Robert_G

...
Wie gesagt, die Idee ist sau cool. Die Technik dahinter auch.
Ich denke dass wäre eine verflucht elegante Lösung gegen das leidige Problem der Typisierung/Generalisierung bei eigenen Collections. :)
Also wie es in .Net mit der expliziten Implementierung erfolgt. ;)

Code:

  void IList.Add(object value)
  {
     Add(MyItemType(value));
  }

  public void Add(MyItemType value)
  {
     ...
  }

Danke nochmal, gefällt mir immer mehr... :thuimb:

Welche idee? und welche technik? Hab grad den kontext verloren, bzw. weiss jetzt nicht auf wen du das beziehst.