Überprüfen ob ein Objekt existiert aber wie?

[Sir Rufo]

Zitat:

Zitat von nahpets (Beitrag 1218669)

Besser? Oder auch noch böse? ;-)

Delphi-Quellcode:

function ObjectExists(aObj: TObject): boolean;
begin
  Result := aObj <> nil;
  if Result then
  try
    Result := aObj.InheritsFrom(TObject);
  except
    Result := false;
  end;
end;

Das Problem liegt doch darin begründet, dass diese Funktion nicht zuverlässig funktioniert.
Es ist reine Glückssache.

Wenn du einen Zufallsgenerator haben möchtest, ist das eine tolle Funktion.
Für die Überprüfung, ob an der Speicherstelle auf die die Referenz zeigt eine gültige Instanz vorliegt, taugt die nicht die Bohne. :roll:

Das Warum findet sich in den Beiträgen hier erläutert

[nahpets]

Zitat:

Zitat von Sir Rufo (Beitrag 1218672)

Zitat:

Zitat von nahpets (Beitrag 1218669)

Besser? Oder auch noch böse? ;-)

Das Warum findet sich in den Beiträgen hier erläutert

Ok, auch böse und wer lesen kann ist klar im Vorteil, stelle mich sofort in die Ecke und schäme mich :oops:

[Medium]

Halten wir doch einfach hier fest:
Eine gültige von einer ungültigen Referenz zu unterscheiden ist im allgemeinen Fall unmöglich, es sei denn man achtet SELBST darauf entweder den Zeiger bei Freigabe zu NILen, oder zumindest den Speicherbereich so zu deformieren, dass solch ein try...ecxept klappen kann. Der einzige andere Weg wären entweder Interfaces (danke Referenzzählung), oder eine eigene Implementierung einer Basisklasse, die ähnlich wie Interfaces agiert.

In praktisch allen anderen Fällen ist es immer möglich, dass ein freigegebenes Objekt zum Prüfzeitpunkt unangetastet im Speicher stehen geblieben ist, womit für das laufende Programm ohne Metainformationen keine Möglichkeit besteht eine Referenz auf diesen Speicherbereich als ungültig zu erkennen, da sowohl die Referenz als auch der referenzierte Speicher exakt gleich aussehen können wie vor der Freigabe des Objektes. End of Story.

(Man könnte höchstens noch versuchen sich in den Speichermanager zu hängen, um dort zu gucken ob die entsprechenden Blöcke als frei markiert wurden. Aber selbst dann: Es könnte dort bereits ein neues Objekt erstellt worden sein, so dass der Speicher als belegt zählt, und schon würde man wieder auf die Nase fallen. Am Ende also auch nur ein schöner Trick, der aber nicht allgemeingültig funktioniert.)

[Furtbichler]

ES gibt zudem kein Einsatzbeispiel, wo es nicht ausreicht, auf '<>Nil' zu prüfen.

Mit anderen Worten: Programmiert einfach so, das sich diese Frage nie stellt, d.h. Kopiert einfach keine Instanzen, wenn während der Lebensdauer der Kopie die Möglichkeit besteht, dass das Original freigegeben wird.

Der Zugriff auf Objekte sollte zudem i.A. immmer über den Eigentümer der Instanz erfolgen, dann kann nichts schiefgehen. Man muss dann nur im Eigentümer die Logik der Lebensdauer implementieren.

[davtix]

Code:

unit unitname;

interface

uses System.Classes,


function FindComponentEx(const Name: string): TComponent;
var
  FormName: string;
  CompName: string;
  P: Integer;
  Found: Boolean;
  Form: TForm;
  I: Integer;
begin
  // Split up in a valid form and a valid component name
  if ( Name = '' ) then
    begin
      EXIT;

      raise Exception.Create('No valid form name given');


    end;

  P := Pos('.', Name);
  if P = 0 then
  begin
    EXIT;
    raise Exception.Create('No valid form name given');
  end;
  FormName := Copy(Name, 1, P - 1);
  CompName := Copy(Name, P + 1, High(Integer));
  Found    := False;
  // find the form
  for I := 0 to Screen.FormCount - 1 do
  begin
    Form := Screen.Forms[I];
    // case insensitive comparing
    if AnsiSameText(Form.Name, FormName) then
    begin
      Found := True;
      Break;
    end;
  end;
  if Found then
  begin
    for I := 0 to Form.ComponentCount - 1 do
    begin
      Result := Form.Components[I];
      if AnsiSameText(Result.Name, CompName) then Exit;
    end;
  end;
  Result := nil;
end;

Code:

 
    procedure oder function .... ; 
    var compo :TComponent;
    begin 
 
        compo := nil;
        compo := FindComponentEx( 'Form4.tempStringGrid101' );
        if ( compo <> nil ) and (compo.ClassType = TJvStringGrid ) then
          begin
            log(9,'add_Entry_database->tempSG4 exist --> FreeAndNil tempSG4');
            //compo:= nil;
            TJvStringGrid( compo ).Free;
          end;
    
     end;

[himitsu]

Bei Copy kann man den letzten Parameter weglassen. Per Default geht es dann bis zum Ende.

Die letzte Schleife ist auch nutzlos, denn FindComponent ist zufällig eine Methode.
Form.FindComponent

Und wenn man dann alles rauskürzt, in etwas aktuelleren Delphis der letzten paar Jahre, dann
(das mit dem VAR seit 10.4)

Delphi-Quellcode:

function FindComponentEx(const Name: string): TComponent;
begin
  var Parts := Name.Split(['.']);
  if Length(Parts) <> 2 then
    raise Exception.Create('No valid name given');
  for var i := Screen.FormCount - 1 downto 0 do
    if AnsiSameText(Screen.Forms[i].Name, Parts[0]) then
      Exit(Screen.Forms[i].FindComponent(Parts[1]));
  Result := nil;
end;

Dann noch bissl weitergesucht und man findet FindGlobalComponent, was auch noch die erste Schleife ersetzt.

Delphi-Quellcode:

function FindComponentEx(const Name: string): TComponent;
begin
  var Parts := Name.Split(['.']);
  if Length(Parts) <> 2 then
    raise Exception.Create('No valid name given');
  Result := FindGlobalComponent(Parts[0]);  // TForm oder TDataMudule
  if Assigned(Result) then
    Exit(Result.FindComponent(Parts[1]));
  Result := nil;
end;

Und weil mir grad langweilig wurde ... naja

Delphi-Quellcode:

function FindComponentEx(Name: string): TComponent;
begin
  Name := Name.Replace('.', '|');
  Result := FindGlobalComponent(GetShortHint(Name));
  if Assigned(Result) then
    Result := Result.FindComponent(GetLongHint(Name));
end;

// oder
function FindComponentEx(Name: string): TComponent;
begin
  Assert(Name.Contains('.'));  // Assert(ContainsStr(Name, '.'));
  Result := FindGlobalComponent(Name.Split(['.'])[0]);
  if Assigned(Result) then
    Result := Result.FindComponent(Name.Split(['.'])[1]);
end;

// oder
tausende andere Lösungswege

GetShortHint/GetLongHint sind Split-Funktionen, die eigentlich für was Anderes gedacht sind, aber die sind einfach zu praktisch,
auch wenn man sie mit einem Copy+Pos nachbauen kann.

Delphi-Quellcode:

GetShortHint(ReplaceStr(Name, '.', '|'))

und

Delphi-Quellcode:

Copy(Name, 1, Pos('.', Name - 1))

liefern das gleiche Result.

[davtix]

ohaaa... danke @himitsu

wer ich morgen mal umschreiben bei mir