Sinn oder Unsinn von Class Helper

[WoGe]

Hallo
nachdem ich jetzt mein schönes? neues Delphi2010 habe, habe ich ich auch Zugang zu (für mich) neuen Konzepten wie Class Helper.
Erst hab ich gedacht: Klasse das hast Du schon immer gebraucht. Leider habe ich zwischenzeitlich entdeckt was man alles nicht darf:

Keine neuen Felder
Kein Zugriff auf Private Variablen
Kein überladen von Konstruktoren

Dadurch entzieht sich mir der Sinn (oder Unsinn) des ganzen Konzeptes.
Könnt Ihr mir bitte sagen für was Class Helper gut sind und vielleicht auch ein wirklich praktischen Beispiel für den Einsatz geben? Kein theoretisches bitte - das habe ich durchaus verstanden - mir ist nur bisher kein praktisches eingefallen.

Gruss
wo

[mirage228]

Wenn ich mich recht entsinne lassen sich Class Helper auch für sealed/final Klassen einsetzen und fügen so neue Methoden zur Klasse hinzu, ohne mit der bisherigen Funktionalität zu interferieren. Auch für sonstige Klassen, an denen Du nichts drehen kannst, aber da ein paar Methoden noch logisch zu gehören, könnten die von nutzen sein.
Allerdings bot sich mir persönlich leider noch keine Gelegenheit die in echt zu probieren, daher auch nur Vermutungen an dieser Stelle...

Viele Grüße

[Daniel]

Ja, genau dann, wenn Du an der Original-Klasse nichts ändern kannst und auch keine Ableitung erstellen willst, können Class-Helper helfen. Und oftmals geht es bei den Anwendungsfällen für Class-Helper auch nicht punktuell um Klassen, die allein für sich im Raum stehen und damit (im Allgemeinen) wunderbar ableitbar wären, sondern vielleicht um Klassen, die wiederum auch von anderen anderen Klassen genutzt werden und damit eine Ableitung nicht unmittelbar weiterhelfen würde.

Ich selbst habe die Class-Helper zum Beispiel genutzt, um die Edit-Controls eines TStringGrids an meine Bedürfnisse anzupassen:

Delphi-Quellcode:

IPEHelper = class helper for TInplaceEdit
public
  procedure UpdateAlignment( AAlignment : TAlignment );
  procedure SetFontName( const aName : string );
  procedure SetFontColor( const aColor : TColor );
  procedure SetFontSize( const aSize : integer );
end;

Auf diese Weise habe ich mir einem Zugang zu Feldern geschaffen, die ich eigentlich nicht hätte ansprechen können.

Hier ein Blog-Eintrag, der einer TStringList mittels Class-Helper ein Rückwärts-Enumerator hinzufügt:
http://17slon.com/blogs/gabr/2007/03...t-5-class.html

[himitsu]

Speziell wenn die Klasseninstanz nicht von dir erzeugt wurde (und man deßhalb nichts daran ändern kann),
dann kann man damit dennoch sehr schön neue Funktionalitäten sozusagen nachträglich hinzufügen.

praktisch so wie z.B. dort
http://www.delphipraxis.net/internal...050126#1050126

[Stevie]

Class helper sind imo der halbgare Versuch, extension methods aus C# nachzubauen.
Sie werden afaik in Verbindung mit dem Gesture Manager in der VCL benutzt.

[WoGe]

Erst mal vielen Dank für die Antworten.

Ich habe mal den Versuch unternommen Speicherplatz für Instanzen bereit zustellen:
(noch sehr rudimentär und seeehhr unschön)

Delphi-Quellcode:

type
  rIchMerkMirwas = Record
    IntMerken : integer;
  End;

  TmyMemo = class helper for TCustomMemo
     private
     function GetMerken: integer;
     procedure SetMerken(const Value: integer);
     public
     procedure Init;
     published
     property Merken : integer read GetMerken write SetMerken;
  end;
...
var 
  myMerkArray : array [0..10] of rIchMerkMirwas;
...

{ TmyMemo }

function TmyMemo.GetMerken: integer;
begin
  result := myMerkArray[Tag].IntMerken;
end;

procedure TmyMemo.Init;
begin

end;

procedure TmyMemo.SetMerken(const Value: integer);
begin
  myMerkArray[Tag].IntMerken := value;
end;

Das ist natürlich erst mal nur eine Machbarkeitsstudie
und das Vorhalten der Daten in einem Globalen-Array ist ja nun nicht wircklich Objektbezogen.

Gibt es eine Möglichkeit das Init direkt und automatisch nach dem Create der Original-Klasse aufzurufen? Da könnte man dann ja viel einfacher eine Verwaltungsstruktur für die Daten implementieren.

Gruss wo

[himitsu]

Zitat:

Gibt es eine Möglichkeit das Init direkt ....

nein,

da die Klasse von dem Helper nichts weiß, ist sowas unmöglich.
nur der Helper kennt seine Klasse und kann diese "steuern" (erweitern paßt irgendwie nicht so ganz)


PS: es gibt theoretisch auch nette Record Helper ... und schon hat man Quasi sowas wie Vererbung bei den Records :angel2:

irgendwelche Standard-Records mit neuen Befehlen und Properties auszustatten wär schon ganz witzig,
oder meint ihr nicht?

Delphi-Quellcode:

type
  TInt64Helper = record helper for TGUID
    function  toStr: String;
    Procedure fromStr(const S: String);
  end;

var G: TGUID;

begin
  WtiteLn(G.toStr);

[jbg]

Zitat:

Zitat von Stevie

Class helper sind imo der halbgare Versuch, extension methods aus C# nachzubauen.

Nachbauen? Wie soll denn das bitte schön gehen, wenn Class Helpers vor den Extension Methods "erfunden" wurden?

[WoGe]

Also man kann die Class Helper austricksen:
Typed Constants gehen nämlich:

Delphi-Quellcode:

function TmyMemo.GetMerken2: integer;
var aPointer : prIchMerkMirwas;
begin
  aPointer := myWertePointer;
  result := aPointer^.IntMerken;
end;

function TmyMemo.myWertePointer: pointer;
const
  myPointer: pointer = nil;
var
  aPointer: pointer;
begin
  aPointer := myPointer;
  if not assigned(aPointer) then
  begin
    aPointer := new(prIchMerkMirwas);
    myPointer := aPointer;
  end;

  result := aPointer;
end;

procedure TmyMemo.SetMerken2(const Value: integer);
var aPointer : prIchMerkMirwas;
begin
  aPointer := myWertePointer;
  aPointer^.IntMerken := Value;
end;

Wie könnte man das Memory-Leak vermeiden?

Aber trotzdem ist das Thema (vorerst) für mich mal erledigt.
Vielen Dank noch mal an Alle

Gruss
wo

[himitsu]

Wo wird da der ClassHelper ausgetrickst?

typisierte Konstanten sind "schreibgeschützte" globale Variablen

Delphi-Quellcode:

function TmyMemo.myWertePointer: pointer;
const
  myPointer: pointer = nil;

entspricht

Delphi-Quellcode:

var
  myPointer: pointer = nil; 
function TmyMemo.myWertePointer: pointer;

wobei das mit den ClassHelpern nichts zu tun hat.

Es gibt da auch einen Compilerschalter (hab nur vergessen welchen, aber der steht eh in der OH), welcher diese Konstanten quasi zu Variablen macht, denen man "offiziell" auch was zuweisen kann.

Und wer absichtlich an der Speicherverwaltugng rumtrickst, der muß auch mit Löchern rechnen.

[WoGe]

@himitsu
Ich glaube das ist so nicht ganz richtig (zumindest meinem bisherigen Wissenstand nach).
Ein typisierte Konstante gehört zur Instanz in der Sie erzeugt wird.
Und damit könnte man sozusagen Instanzvariablen erzeugen.

Mein Memoryleak kommt ja nur daher, das ich weitere Datenstrukturen mittels New erzeuge und ich die Stelle wo ich die wieder freigeben kann noch nicht entdeckt habe.

Grüsse
wo

[sh17]

class helper kann man nicht zufällig von einem Objekt ableiten?

Habs zumindest nicht hinbekommen, wäre aber hilfreich.

[mkinzler]

Wie meinst du das? Ein Class Helper erweitert ja eine Klasse ohne sie abzuleiten

[sh17]

Delphi-Quellcode:

TMeineKlasse = class(TDieKlasse)
end;

TMeineKlasseHelper = class(TAndereKlasse) helper for TMeineKlasse
end;

Quasi so, sozusagen indirekte Mehrfachvererbung.

//Edit:

Mach es grad über verschachtelte Klassen, Helper wäre aber eleganter gewesen.

[mkinzler]

Delphi unterstützt, wie auch Java und c# aus guten Grund keine Megrfachvererbung. Zudem sind class helper kein vollständiger Ersatz für Ableitung, da man durch sie nur erweitern kann aber nicht Überladen oder Überschreiben.

[stahli]

Ein sehr interessantes Video zu "class helper".

Werde ich mal testen, ob sich mein aktuelles Problem damit erschlagen lässt.
Ich habe allerdings auch von Compilerproblemen gelesen - dass es also praktisch (in größerem Umfang) nicht wirklich einsetzbar ist (oder früher war).


Zu meinem Hintergrund:

Ich habe in einer Basisunit Datenklassen, die anhand einer festgelgten Struktur komplett durch einen "Experten" erstellt werden und sich gegenseitig referenzieren können. Ist ja kein Problem, solange alle in einer Unit stehen.
In meinem "richtigen" Projekt will ich jedoch zusätzliche Methoden nutzen, die entsprechend Daten lesen und ändern und auch andere Instanzen suchen und verwenden. Da die Instanzen aus den Basisklassen erzeugt werden müsste ich immer mit Typecasts arbeiten wenn ich die neuen Methoden in Kindklassen einführe.

Im Moment erzeuge ich die Instanzen daher erst von den Kind-Klassen, das kann nach Änderungen der Datenstrukturen jedoch dann nicht mehr durch den Experten automatisch erfolgen. Außerdem wäre es einfach übersichtlicher, wenn diese Sachen direkt in den Basisklassen erfolgen könnten.

In den Helperklassen sehe ich nun einen potentiellen Ausweg und werde das mal versuchen - wobei mir ein Multipass-Compiler im Delphi auf jeden fall deutlich lieber wäre.

[DualCoreCpu]

Ich experimentiere gerade mit fclimage aus Freepascal rum. Will dort 2 Methoden aus TfpCustomcanvas überschreiben, die dort protected und virtual abstract deklariert sind.

Da ich zeichnen will, habe ich die TfpPixelcanvas Klasse ausgewählt. FPC sagt mir nun aber, daß es keine Methoden dieses Namens in der Ursprungsklasse gebe. Bei TfpPixelcanvas trifft das auch zu, diese Klasse ist aber von TfpCustomCanvas abgeleitet. Dort aber befinden sich die Methoden, die ich überschreiben will. Ich habe hinter der überschriebenen Methode die override Direktive gesetzt und verstehe jetzt nicht, was daran falsch ist.

Ich stelle die Frage hier, weil ich hoffe, mittels Helper Klassen, die es in FPC 3.0.0 auch gibt, eine Lösung zu finden. Kann ich damit auf die Protected Methoden zugreifen. Oder sollte ich eine andere Canvas Klasse nach dem Vorbild von TFPpixelCanvas ableiten.

Ich wollte eigentlich die fpPixelCanvas Klasse verwenden und die fehlenden Methoden, die in FPCustomcanvas abstract deklariert sind, in meiner Klasse ableiten, da alle Zeichenmethoden in TfpPixelcanvas bereits implementiert sind. Nun tritt aber das beschriebene Problem auf.


Ist das vielleicht ein Fall für die Helper Klassen???