Im with statement obj referenzieren

[DGS]

Tach.

ich stehe vor einer Aufgabe und habe Probleme die richtigen Worte zu finden dazu.

Jedenfalls Ausgangslage:
Ich benutze eine with Konstruktion, um u.a. Variablennamen einzusparen. Verwende ich für ein Stream.

Hier ein fetzen des relevaten Codes:

Delphi-Quellcode:

function tForm1.lesen( datei: String; var stream : tStream) : boolean;
var i : int;
begin
  with tFileStream.Create( datei, fmOpenRead) do begin
    {...}
    stream.CopyFrom( XXX, i );
    {...}
    free;
  end;
end;

Was ich nun möchte:
Aus dem erstellten tFileStream will ich ne Stelle in stream kopieren.

Das Problem:
Welche referenz soll ich nutzen? ( Stelle mit XXX markiert )
ein self liefert nur (in diesem Beispiel ) Form1, nicht aber den temporären stream.

Kann man das irgendwie mit with trotzdem lösen, oder komm ich um eine weitere Variable nicht herum?
Also sowas:

Delphi-Quellcode:

function tForm1.lesen( datei: String; var stream : tStream) : boolean;
var 
  i : int;
  t : tStream;
begin
  t := tFileStream.Create( datei, fmOpenRead);
  {...}
  stream.CopyFrom( t, i );
  {...}
  t.free;
end;

Also dieser Code tut das, was ich auch will.
Wenn also mit with nicht gehen sollte, dann nehme ich auch den. Nur möcht ich halt wissen, ob es wirklich nicht möglich ist, oder ob doch man was machen kann.

Gruss

[Apollonius]

Nein, das geht nicht. Falls doch, würde es mich aber auch interessieren.

[DGS]

Tja, schade eigentlich, dass es nicht geht.
Hab aber auch nicht wirklich erwartet, dass es klappen wird.
Dann muss halt ne zusätzliche Variable her.

[SirThornberry]

bin ich froh das es nicht geht :-D Ich bin jemand der das Width überhaupt nicht mag weil oft nicht ersichtlich ist ob es innerhalb des blocks um eine Eigenschaft des With-Parameter handelt oder um eine eigenständige Variable. Oft kommt es dort auch zu fehlern.

Bsp.:

Delphi-Quellcode:

procedure TMyComponent.Methode();
begin
  with AnComponent do
  begin
    [...]
    Name := 'irgendwas';
    [...]
    //teilweise auch schon gesehen
    Name = AnComponent.Name;
    [...]
  end;
end;

[RavenIV]

Zitat:

Zitat von SirThornberry

bin ich froh das es nicht geht :-D Ich bin jemand der das Width überhaupt nicht mag weil oft nicht ersichtlich ist ob es innerhalb des blocks um eine Eigenschaft des With-Parameter handelt oder um eine eigenständige Variable. Oft kommt es dort auch zu fehlern.

Da schlag ich gleich auch in die selbe Kerbe.
Wenn ich irgendwo im Quellcode (eines Kollegen oder so) auf ein with stosse, wird dies ersatzlos eliminiert.
Vor allem hat der Debugger damit ein Problem, weil er die Variablen nicht auflösen kann. Beim "Drüberfahren" zeigt er den Wert der Variablen nicht an.
Und das menschlische Auge sieht auch nicht sofort, wo eine Property dazugehört. Geil wird es aber erst, bei mehrfachen oder verschachtelten with. Dann kommt weder der Compiler noch der Debugger noch der Mensch mehr klar.

[DGS]

Je nach Mensch natürlich. Ich konnte da bisher gut mitverfolgen, was passiert.

Also würdet ihr alle eh generell von der With-Konstruktion abraten?
Dafür lieber eine Variable mehr deklarieren?

[mkinzler]

Ohne with ist es eindeutiger und imho leichter zu sehen zu welcher variable die Eigenschaft/Methode gehört

[alzaimar]

Ich bin wohl der einzige auf der Welt, der mit 'with' gerne arbeitet.
Statt

Delphi-Quellcode:

Foo.Bar.Grumpy.Steve.Bob.Jim.Arm  := 1;
Foo.Bar.Grumpy.Steve.Bob.Jim.Leg  := 2;
Foo.Bar.Grumpy.Steve.Bob.Jim.Head  := 3;

dann doch lieber

Delphi-Quellcode:

With Foo.Bar.Grumpy.Steve.Bob.Jim do Begin
  Arm  := 1;
  Leg := 2;
  Head := 3;
End;

Bei Mehrdeutigkeiten lass ich es natürlich sein und verwende für Jim vielleicht eine lokale Variable, aber Konstrukte wie

Delphi-Quellcode:

With TMyForm.Create (nil) do begin
  If ShowModal = mrOk Then DoSomeThing;
  Release
End;

sind doch echt nett.

Aber es ist egal, ob nun mit 'with' oder nicht. Ihr wollt es übersichtlich und lesbar, ich auch. Und darum geht es letztendlich.

[Amateurprofi]

Ich liebe with-Statements und benutze sie immer dann, wenn der Source-Code dadurch kürzer wird.

@Sir T. :
Für mich wird dadurch der Code übersichtlicher.

@RavenIV :
Der Compiler kommt damit sehr wohl klar (und ich auch). Lediglich der Debugger hat damit Probleme, aber die nehme ich gern in Kauf.

Und was denken die Profis (ich bin ja nur ein AmateurProfi)?:
Einfach mal in die Delphi Source Codes schauen.

[Whookie]

Also ich würd auch sagen "Finger weg" vom with Statement (obwohl ich es früher auch gerne verwendet habe ... es bringt vor allem langfristig NUR Probleme mit sich!!

@alzaimar so ist es viel besser:

Delphi-Quellcode:

Var
  jim: TFooObject;
Begin
  jim := Foo.Bar.Grumpy.Steve.Bob.Jim;
  jim.Arm := 1;
  jim.Leg := 2;
  jim.Head := 3;

[alzaimar]

Zitat:

Zitat von Whookie

@alzaimar so ist es viel besser:

Findest Du. Ich nicht. Die lokale Variable ist nämlich überflüssig und unnötig. Jedenfalls für die, die lesen können. :mrgreen:

[Whookie]

Zitat:

Zitat von alzaimar

Findest Du. Ich nicht. Die lokale Variable ist nämlich überflüssig und unnötig. Jedenfalls für die, die lesen können. :mrgreen:

[offtopic]
Mein Gott, ich bin halt scho a bisserl älter und seh nimmer so scharf :mrgreen: , ausserdem was kümmert mich so a pointer :angel2:
[/offtopic]

[DGS]

Zitat:

Zitat von Whookie

ausserdem was kümmert mich so a pointer :angel2:

Das sind ganze 4 Byte, die der Pointer alleine für Speicheradresse braucht. Was sonst noch dazukommt weis ich nicht.

Dürften Peanuts sein, solange man nen Windows PC vor sich hat.

[alzaimar]

Zitat:

Zitat von Whookie

[offtopic]
Mein Gott, ich bin halt scho a bisserl älter und seh nimmer so scharf :mrgreen:
[/offtopic]

Wenn Du immer deine Medizin nehmen würdest, so wie ich, dann könntest Du auch besser lesen. Du bist ja noch richtig jung, ganz im Gegensatz zu mir. :zwinker:

Zitat:

Zitat von DGS

Dürften Peanuts sein, solange man nen Windows PC vor sich hat.

Aber die Ästhetik! :warn:

:tongue:

[oki]

Hi,

erst mal zum Thema: geht so nicht.

Nun zum with; Ich mag diese Konstrukte auch nicht. Erstens werd ich immer unsicher, was benutzt wird wenn self die gleiche Eigenschaft enthält, und wenn ich dann immer die "fremde" Instanz davor setzen muß, dann komme ich auch wieder auf mehr Text.

Bsp.: Was passiert hier wirklich?

Delphi-Quellcode:

procedure MyObject.Assign(Source : MyObject);
begin
  with Source do begin
    Caption := Caption;
    Left := Left;
.......
end;

Gruß oki

[DGS]

Zitat:

Zitat von oki

Bsp.: Was passiert hier wirklich?

Delphi-Quellcode:

procedure MyObject.Assign(Source : MyObject);
begin
  with Source do begin
    Caption := Caption;
    Left := Left;
.......
end;

Meine Vermutung:

Delphi-Quellcode:

procedure MyObject.Assign(Source : MyObject);
begin
  Source.Caption := Source.Caption;
  Source.Left    := Source.Left;
.......
end;

Hab bisher noch nicht getestet. So würde ich es aber wie gesagt erwarten.

*edit:
Hab mal Beispiel hinzugefügt.

[mkinzler]

Aber allein die Tatsache, dass man es nicht genau sagen kann, sollte einem von der Verwendung abhalten.

[oki]

Aber auch nicht sicher, oder? :lol:

Das ist natürlich ein Situation, in der das keiner tun würde. Aber genau wegen dieser Unsicherheit lasse ich das with lieber weg. Ich persönlich halte den Code dann auch für besser lesbar.

Gruß oki
[edit] grrrr, roter Kasten! Meine ansage mit auch nicht sicher bezog sich auf DGS Beitrag [/edit oki]

[Sidorion]

Steht doch ganz klar in der OH. Innerhalb eines With hat immer das gewithte :mrgreen: Objekt vorrang.

[oki]

und somit müßte ich folgendes tun:

Delphi-Quellcode:

procedure MyObject.Assign(Source : MyObject);
begin
  with Source do begin
    self.Caption := Caption;
    self.Left := Left;
.......
end;

Was in diesem Bsp. natürlich unsinnig ist, da es mehr Schreibarbeit verursacht, aber aufpassen muß mann immer noch mächtig. Da schleicht sich imho schnell ein Fehler ein; und den dann finden? Ich bin in der regel bei meinem Code in Punkto Fehlersuche immer etwas betriebsblind.
Ist halt aber auch alles meine persönliche Meinung und somit nicht repräsentativ.

Gruß oki

[Tormentor32]

Ich benutze das with-Konstrukt nur an den Stellen, wo ich mir sicher sein kann, um welche Properties es sich handelt, die ich da veränder/abfrage und wo ich damit jede Menge Text sparen kann.

[bernau]

Zitat:

Zitat von Whookie

@alzaimar so ist es viel besser:

Delphi-Quellcode:

Var
  jim: TFooObject;
Begin
  jim := Foo.Bar.Grumpy.Steve.Bob.Jim;
  jim.Arm := 1;
  jim.Leg := 2;
  jim.Head := 3;

So verwende ich es auch immer öfter. Grade beim Debuggen sind "Hilfsvariablen" wirklich nett und es ist manchmal wirklich besser lesbar.

Meine with-Statements werden so langsam im Code verbannt.

[alzaimar]

:gruebel: Ihr habt euch aber wirklich.

Nur weil ich mit einem Prozeduraufruf eine Endlosrekursion produzieren kann, heisst das doch noch nicht, das ich gänzlich auf Prozeduren verzichte :mrgreen:

Konstrukte, egal welcher Art, sollten da eingesetzt werden, wo es passt. Bei einer Zuweisung einzelner Eigenschaften zweier Instanzen ein und der selben Klasse, würde nur dann mit 'WITH' arbeiten, wenn ich den Rest der Coder-Gemeinschaft nachhaltig verärgern will.

Natürlich schreibt man dann:

Delphi-Quellcode:

Procedure TMyObject.Assign (aSrc : TMyObject);
Begin
  Self.Foo := aSrc.Foo;
  Self.Bar := aSrc.Bar;
...
End;

Wenn ich aber auf Jim's Körperteile eingehen will, wäre ein WITH durchaus adäquat. Auch die Verwendung bei der kurzzeitigen Verwendung einer Klasseninstanz ist das imho die richtige Wahl: Die Instanz ist so kurzlebig, das sie noch nicht mal eine eigene lokale Variable verdient. Das oi

Wie gesagt: Man *kann* damit furchtbar unleserlichen Müll fabrizieren. Aber das geht mit Vererbung, Methodenaufrufen und
Programmierung allgemein auch sehr einfach.

[RavenIV]

Zitat:

Zitat von bernau

Meine with-Statements werden so langsam im Code verbannt.

Also ich bin irgendwie allergisch gegen das with.
Woimmer ich darüber stolpere, fliegt es raus.
Und im Code meiner Vorgänger kommt (kam) sowas sehr viel vor.

Einzige Ausnahme, wo es für mich Sinn macht:

Delphi-Quellcode:

with Irgendwas.create(...) do
begin
  PropertyX := ...;
  PropertyY := ...;
end;

[oki]

Ich will noch mal betonen, dass ich nichts gegen with-Konstrukte habe! Nur wenn ich halt mal einen Fehler finden muß fällt mir der Variablenkonstrukt einfach leichter.

Das man an der richtigen Stelle 'ne Menge Schreiberei mit with spaaren kann ist auch unbestritten. Aber genau damit

Zitat:

Zitat von Tormentor32

Ich benutze das with-Konstrukt nur an den Stellen, wo ich mir sicher sein kann, um welche Properties es sich handelt, die ich da veränder/abfrage und wo ich damit jede Menge Text sparen kann.

bin ich auch schon auf die Nase gefallen.

Gruß oki

[marabu]

Hi folks,

Prof. Wirth hat das WITH-Statement bereits in seinem Ur-Pascal nicht ohne Grund eingeführt. Wichtig war ihm die einmalige Auswertung des Ausdrucks im WITH-Statement, was richtig angewandt zu Effizienz und Übersichtlichkeit gleichermaßen führt:

Delphi-Quellcode:

with TFileStream.Create(fn, fm) do
begin
  Write(buf, bufSize);
  Free;
end;

Auch Borland verwendet positive Vokabeln zur Beschreibung dieses Sprachmerkmals: einfach, bequem, effizient, kurz. Beim GREP über das SOURCE Verzeichnis von Delphi merkt man, dass die Borland-Entwickler keine Scheu hatten es zu benutzen.

In Modula hat Wirth das WITH-Statement überarbeitet. Die Einmalauswertung wollte er unbedingt beibehalten, aber das Überdeckungsproblem machte ihm wohl Sorgen. Als Lösung schuf er die Bindung des Ausdrucks an eine Variable, die nur im WITH-Statement verfügbar ist:

Delphi-Quellcode:

// no valid delphi code
with fs = TFileStream.Create(fn, fm) do
begin
  fs.Write(buf, bufSize);
  fs.Free;
end

In Oberon hat er das WITH-Statement aus übergeordneten Gesichtspunkten eliminiert - er wollte eine Sprache schaffen, die im Tugendvergleich mit ihren Vorgängern ähnlich da stehen sollte, wie RISC vs. CISC. Das Motto war KISS - Keep It Small, Simple.

Ich sehe in den Beiträgen dieses Threads eher persönliche Erfahrungsberichte als Argumente für und wider. Auch wenn ich das WITH-Statement häufig benutze, möchte ich niemanden bekehren, aber ein paar Dinge möchte ich gerne los werden:

Als Software-Entwickler erzeugen wir in erster Linie Programm-Quelltexte für diejenigen, die nach uns kommen. Wenn der Code korrekt ist, dann gibt es keinen Grund ihn (äquivalent) umzuformen, also wird kein Profi freigegebenen Code verändern, wenn er es nicht muss. Wir schreiben unseren Code nicht für irgendeinen Runtime-Debugger und wenn ich mit dem Cursor innerhalb eines WITH-Statements über einen Bezeichner halte, dann meldet mir die D7-IDE den zugehörigen namespace.

Die Unübersichtlichkeit mancher Code-Strecken ist meiner Menung nach häufiger viel zu großen Funktionen geschuldet, als falsch angewandten WITH-Statements. Funktionale Programmierung und die konsequente Modularisierung führen zu Funktionen, die man mit einer oder beiden Händen abdecken kann. Wer dann noch fachbezogenen und abstrakten Code auf verschiedenen Ebenen ansiedelt, der macht sich um WITH-Statements kaum noch Sorgen.

Begreift WITH-Statements einfach als Freiheitsgrade der sprachlichen Ausdrucksfähigkeit von Object Pascal. Es sind dynamische default namespaces - nicht mehr und nicht weniger. Benutzt sie oder lasst es halt, aber lasst euch nicht beim Missionieren erwischen.

Freundliche Grüße

[bernau]

Zitat:

Zitat von RavenIV

Einzige Ausnahme, wo es für mich Sinn macht:

Delphi-Quellcode:

with Irgendwas.create(...) do
begin
  PropertyX := ...;
  PropertyY := ...;
end;

Eben so ein Konstrukt ist für mich tabu. Dort gibt es gar keine Möglichkeit mit einem Debugger auf die Werte zuzugreifen.

Wenn irgendetwas instanziert wird, dann landet es erst mal in einer Variablen.

Delphi-Quellcode:

fIrgendwas:=TIrgendwas.create(...)
fIrgendwas.PropertyX := ...;
fIrgendwas.PropertyY := ...;

[semo]

Zitat:

Dort gibt es gar keine Möglichkeit mit einem Debugger auf die Werte zuzugreifen.

klar geht das mit evaluate / modify und watches...

und meiner meinung macht es gerade bei solchen konstruktoren sinn "with" zu verwenden, wenn viele zu initialisierenden parameter vorhanden sind.

[bernau]

Zitat:

Zitat von M. Hassmann

klar geht das mit evaluate / modify und watches...

Vieleicht lerne ich noch was dazu

Folgender Code:

Delphi-Quellcode:

with TStringList.Create do
  begin
    Add('aaa');
    Add('aaa');
    Add('aaa');
    Add('aaa');
  end;

wie sieht die Expression aus, die ich in der Watchlist eingeben muss, um mir das property "count" der Stringliste anzeigen.

Nur "Count" geht nicht. Eine Variable (z.B. "fStringlist"), auf die ich zugreifen kann, ist nicht vorhanden.

[bernau]

@marabu: Sehr schöne Zusammenfassung.

[semo]

@bernau:
man schalte in den projektoptionen die debug dcus an.
springe in das jeweilige add() mit f7 rein und kann per self.count den count ausgeben lassen.

[oki]

Zitat:

Zitat von M. Hassmann

und kann per self.count den count ausgeben lassen.

Wenn ich diesen Konstrukt in einer Klassenmethode verwende wird dann self (der Klasse) zum self auf With referenziert? Das wage ich zu bezweifeln. Oder betrifft das nur den Debuger?

Gruß oki

[RavenIV]

Zitat:

Zitat von M. Hassmann

@bernau:
man schalte in den projektoptionen die debug dcus an.
springe in das jeweilige add() mit f7 rein und kann per self.count den count ausgeben lassen.

Hast Du schon mal ein Projekt debuggt, das grösser als einige Zeilen Code ist?
Und wenn Du die Zeit und die Musse hast, erst mit F7 da reinzuspringen und dann weiterzudebuggen, von mir aus...
Ich hab dies nicht und möchste beim Drüberfahren angezeigt bekommen, welchen Wert welche Variable grad hat oder was bei einer Berechnung rauskommt.

[bernau]

Zitat:

Zitat von M. Hassmann

@bernau:
man schalte in den projektoptionen die debug dcus an.
springe in das jeweilige add() mit f7 rein und kann per self.count den count ausgeben lassen.

Nun ja, so könnte man es machen. Aber es ist nicht wirklich elegant, da ich aus dem zu prüfenden Quellcode herausgerissen werde und den Kontext zum ursprünglichen Quelltext verliere. Dann lieber die Variable definieren.

[semo]

kommt natürlich auf den fall drauf an.
bei einem add weiß man das der count um eins erhöht wird :-)

[OlafSt]

Ich benutze WITH sehr oft - und ich bin bisher immer gut damit gefahren in den letzten 16 Jahren, in denen ich Pascal/Object Pascal code.

Während der Entwicklung verwende ich WITH nur bei Initialisierungen von Records oder Objekten:

Delphi-Quellcode:

with SunsiteRec do
begin
  x1:=1;
  x2:=19;
  //Text:='';
  Msg:='';
end;

Im Debugger habe ich ohnehin den SunsiteRec als Watch mit ",r"-Parameter drin, sehe also gleich, ob alles glattgeht. Ansonsten wird erstmal ausformuliert, auch um solche Mehrdeutigkeiten wie "Caption:=Caption" und ähnliches sofort zu erkennen und bei der Deklaration von Objekten von vornherein zu eliminieren.

Delphi-Quellcode:

SunsiteRec.x1:=RxNumberEdit1.IntValue-217;
SunsiteRec.x2:=RxNumberEdit2.IntValue div 4;
//SunSiteRec.Text:=Edit1.Text;
SunsiteRec.Msg:=Edit1.Text;

Wenn der Code durchgetestet wurde und läuft, wird das ausformulierte durch WITH zusammengekürzt, Mehrdeutigkeiten - sofern noch vorhanden - bleiben dann einfach stehen. Laut OH löst der Compiler dann das WITH-Element nur einmal auf und nicht jedesmal, trägt also auch zur Optimierung bei.

Delphi-Quellcode:

with SunsiteRec do
begin
  x1:=RxNumberEdit1.IntValue-217;
  x2:=RxNumberEdit2.IntValue div 4;
  //SunSiteRec.Text:=Edit1.Text;
  Msg:=Edit1.Text;
end;

Ich habe schon ein paar Millionen Zeilen Code produziert und nie Probleme gehabt - auch nicht mit den Nachfolgern, die nach mir ein Projekt weiterbetreuten.

[RavenIV]

Zitat:

Zitat von OlafSt

Im Debugger habe ich ohnehin den SunsiteRec als Watch mit ",r"-Parameter drin, sehe also gleich, ob alles glattgeht.

Was ist SunsiteRec?

Zitat:

Zitat von OlafSt

Ansonsten wird erstmal ausformuliert, auch um solche Mehrdeutigkeiten wie "Caption:=Caption" und ähnliches sofort zu erkennen und bei der Deklaration von Objekten von vornherein zu eliminieren.

Wenn der Code durchgetestet wurde und läuft, wird das ausformulierte durch WITH zusammengekürzt, Mehrdeutigkeiten - sofern noch vorhanden - bleiben dann einfach stehen. Laut OH löst der Compiler dann das WITH-Element nur einmal auf und nicht jedesmal, trägt also auch zur Optimierung bei.

Man kann sich auch mehr Arbeit machen, als nötig...

[alzaimar]

Zitat:

Zitat von RavenIV

Man kann sich auch mehr Arbeit machen, als nötig...

Auf diese Weise entstehen eben Unterschiede in der Codequalität. :zwinker:

[merlin17]

ich bin zwischenzeitlich auch etwas vom "with" weggekommen... die Gründe wurden oben ja schon erwähnt.
Habe hier Castalia 5 zu schätzen gelernt:

Im Castalia Refactoring:

Eliminate "With" - resolves a with clause, removing the "with" block and placing appropriate references where the block had been.



:-) thomas

[DerDan]

Hallo Leutz


1) ich kenne einen der in C++ programmiert und sagt, das er gerne eine With Statement hätte.
2) in Visual Basic gibt es auch ein With Statement dort muss man aber einen Punkt (.) vor die Variable schreiben,
damit die ge"with"te Variable / Property verwendet wird.

grade der zweite Punkt fände ich unter Delphi nicht schlecht.

dann würde das in etwa so aussehen:

Delphi-Quellcode:

with SunsiteRec do
begin
  .x1 := 1;
  .x2 := 19;
  //Text:='';
  .Msg := '';
end;

aber merkt ihr eigentlich, das wir schon lange OT sind?

mfg

derDan