Code Optimierung zu ".. is <type>"

[TigerLilly]

Ich habe eine Reihe solcher Konstrukte:

Code:

if (Component is TLabel) then begin
    if pos('||', (Component as TLabel).Caption) = 0 then begin
        ....
        (Component as TLabel).Caption :=  (Component as TLabel).Caption + ' || ' + s;
      end;
    end;
end;

Optimiert das der Compiler oder wäre ein

Code:

if (Component is TLabel) then begin
    Label:=TLabel(Component);
    if pos('||', Label.Caption) = 0 then begin
        ....
        Label.Caption :=  Label.Caption + ' || ' + s;
      end;
    end;
end;

eine sinnvolle Optimierung?

Danke für Input!

[lxo]

Auf jeden Fall ist (lComponent as TLabel) langsamer als TLabel(lComponent).
TLabel(lComponent) aber vorher in eine Variable vom Typen TLabel zu schreiben scheint keinen Unterschied zu geben.

Hier einmal ein Beispiel.

Wieso das so ist kann ich aber auch nicht genau sagen, würde mich aber auch interessieren.

Delphi-Quellcode:

type
  TTest = class
    Int: Integer;
  end;
procedure TForm105.Button1Click(Sender: TObject);
var
  lObject: TObject;
  i : Integer;
  lStopwatch: TStopwatch;
  lTest: TTest;
begin
  lObject := TTest.Create;
  try
    lTest := TTest( lObject);
    lStopwatch := TStopwatch.StartNew;
    for I := 0 to MaxInt do
    begin
//      (lObject as TTest).Int := i; // 8,7 Sekunden
//      TTest( lObject).Int := i;    // 2,5 Sekunden
//      lTest.Int := i;              // 2,5 Sekunden
    end;
    lStopwatch.Stop;
    ShowMessage( lStopwatch.Elapsed.Duration.ToString);
  finally
    lObject.Free;
  end;
end;

[stahli]

Belegen kann ich das nicht, aber würde denken, dass es eine theoretische aber real kaum messbare Verzögerung gibt.
Du kannst ja die Stelle 10 Mio mal durchlaufen lassen und die Zeiten messen.

Allerdings würde ich allein aus Gründen der Lesbarkeit schon die zweite Form (temporäre Zwischenvariable) wählen.

[Der schöne Günther]

Wenn man so etwas öfter macht lohnt sich evtl. auch so etwas hier, da bekommt man mit den Generics gleich Typsicherheit rein und brauch gar nichts mehr casten:

https://www.delphipraxis.net/194401-...ml#post1386380

[Uwe Raabe]

Wenn du die Zwischenvariable nicht willst, kannst du nach dem

Delphi-Quellcode:

if Component is TLabel then

bedenkenlos den Cast

Delphi-Quellcode:

TLabel(Component)

innerhalb des then-Scopes verwenden. Du hast da ja bereits sichergestellt, das Component wirklich ein TLabel ist.

[TigerLilly]

Zitat:

Auf jeden Fall ist (lComponent as TLabel) langsamer als TLabel(lComponent)

Ja, das liegt daran, dass das as eine Typüberprüfung macht, wähend hardcasting das nicht macht. Ok, das wäre - wie Uwe sagt - ein erster Ansatz.

Dennoch: Bringt der Weg über die Zwischenvariable was?

[Uwe Raabe]

Zitat:

Zitat von TigerLilly (Beitrag 1503167)

Dennoch: Bringt der Weg über die Zwischenvariable was?

Nur beim Schreiben und Lesen. In diesem Fall kannst du ja auch Gebrauch von einer Inline-Variablen machen. Die gibt es dann nur zwischen dem

Delphi-Quellcode:

then begin

und

Delphi-Quellcode:

end

.

Delphi-Quellcode:

if (Component is TLabel) then begin
    var Label:=TLabel(Component);
    if pos('||', Label.Caption) = 0 then begin
        ....
        Label.Caption := Label.Caption + ' || ' + s;
      end;
    end;
end;

[Harry Stahl]

Zitat:

Zitat von lxo (Beitrag 1503162)

Auf jeden Fall ist (lComponent as TLabel) langsamer als TLabel(lComponent).
TLabel(lComponent) aber vorher in eine Variable vom Typen TLabel zu schreiben scheint keinen Unterschied zu geben.

Hier einmal ein Beispiel.

Wieso das so ist kann ich aber auch nicht genau sagen, würde mich aber auch interessieren.

Delphi-Quellcode:

type
  TTest = class
    Int: Integer;
  end;
procedure TForm105.Button1Click(Sender: TObject);
var
  lObject: TObject;
  i : Integer;
  lStopwatch: TStopwatch;
  lTest: TTest;
begin
  lObject := TTest.Create;
  try
    lTest := TTest( lObject);
    lStopwatch := TStopwatch.StartNew;
    for I := 0 to MaxInt do
    begin
//      (lObject as TTest).Int := i; // 8,7 Sekunden
//      TTest( lObject).Int := i;    // 2,5 Sekunden
//      lTest.Int := i;              // 2,5 Sekunden
    end;
    lStopwatch.Stop;
    ShowMessage( lStopwatch.Elapsed.Duration.ToString);
  finally
    lObject.Free;
  end;
end;

Da kann man sich ja mal ansehen, was der Compiler draus macht (siehe Anlage).

Bei "as" erfolgt noch ein Sprung woanders hin (in die system.pas, und dort werden eine Reihe von Befehlen abgearbeitet), das kostet zeit..

[freimatz]

Zitat:

Zitat von Harry Stahl (Beitrag 1503170)

Bei "as" erfolgt noch ein Sprung woanders hin (in die system.pas, und dort werden eine Reihe von Befehlen abgearbeitet), das kostet zeit..

Ich behaupte: das hängt von der Betrachtungsweise ab :-D
Ja es kostet CPU-Zeit. Ohne das kann es aber wesentlich mehr Entwickler-Zeit kosten.
Ich meine: wenn man nicht sehr abstruse Dinge machen kann ist in der UI die Zeit für das is oder as vernachlässigbar. Besser ist es so zu machen wie Uwe es vorgeschlagen hat.

[Harry Stahl]

Zitat:

Zitat von freimatz (Beitrag 1503180)

Zitat:

Zitat von Harry Stahl (Beitrag 1503170)

Bei "as" erfolgt noch ein Sprung woanders hin (in die system.pas, und dort werden eine Reihe von Befehlen abgearbeitet), das kostet zeit..

Ich behaupte: das hängt von der Betrachtungsweise ab :-D
Ja es kostet CPU-Zeit. Ohne das kann es aber wesentlich mehr Entwickler-Zeit kosten.
Ich meine: wenn man nicht sehr abstruse Dinge machen kann ist in der UI die Zeit für das is oder as vernachlässigbar. Besser ist es so zu machen wie Uwe es vorgeschlagen hat.

Ich habe ja gar keine Aussage dazu gemacht, wie man es besser macht, sondern wollte nur die Erklärung zeigen, warum das unterschiedlich schnell ist...

[Blup]

:thumb: Gut zu wissen.

MaxInt ist etwas über 2,1 Milliarden. Wenn man tatsächlich mal eine Anwendung schreibt die 200.000.000 unsichere Typ-Cast ausführt, spart das 6,2 Millisekunden Laufzeit.
Wie viel Entwicklungszeit sich bei der Fehlersuche sparen lässt, wenn man statt dessen "as" verwendet, lässt sich leider nicht testen.
:roll:

[BerndS]

Ich hatte erwartet, dass nach Uwes Beitrag die Frage beantwortet ist. Denn nach der ersten if Component is TLabel macht eine weitere Prüfung per as doch keinen Sinn mehr.
Man könnte es aber auch so machen. Aber with sollte ja nicht mehr verwendet werden.
Hier wird die Typenprüfung gemacht und für den Fall, dass dieser nicht passt die Exception abgefangen.

Delphi-Quellcode:

   try
     with (Component as TLabel) do
       if pos('||', Caption) = 0 then 
       begin 
         ....
         Caption := Caption + ' || ' + s;
      end;
    except
    end;

Ohne with würde ich diese Variante verwenden.

Delphi-Quellcode:

  if (Component is TLabel) then 
  begin
    if pos('||',TLabel(Component).Caption) = 0 then 
    begin
      ....
      TLabel(Component).Caption := TLabel(Component).Caption + ' || ' + s;
    end;
  end;
end

Die Verwendung einer weiteren Variante ist so nicht notwendig.

[Blup]

Ich bevorzuge diese Variante:

Delphi-Quellcode:

procedure TuAllesMögliche(Sender: TObject);

  procedure TuWasMitLabel(ALabel: TLabel);
  begin
    if pos('||', ALabel.Caption) = 0 then
    begin
      ....
      ALabel.Caption := ALabel.Caption + ' || ' + s;
    end;
  end;

begin
  if Sender is TLabel then
    TuWasMitLabel(TLabel(Sender));
end;