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.