Problem mit Constructor/Destructor

[Zacherl]

Die von dir designte Klasse ist höchst "interessant". Ich würde es so lösen:

Delphi-Quellcode:

type  
  TContainer = class(TObject)
  private
    FFileName: String; 
    FInvalidFile: Boolean;
  public
    procedure DoSomeThing;
    constructor Create(const FileName: String; AsReadOnly: Boolean);
    destructor Destroy;
  published
    property InvalidFile: Boolean read FInvalidFile;
  end;

Dann kannst du im Create prüfen ob die Datei geöffnet werden kann und ansonsten setzt du FInvalidFile auf true. In keinen Fall darfst du im Constructor Destroy aufrufen. Das ist tödlich

[Sir Rufo]

Destroy sollte generell nicht aufgerufen werden, sondern Free.
Im Constructor allerdings auch kein Free

Das Zerstören einer Instanz setzt die Referenzen nicht auf nil.
Darum muss man sich selber kümmern (gibt da ein FreeAndNil aber das würde auch nur diese eine Referenz-Variable auf nil setzen)

[jfheins]

Auch keine gute Lösung. Denn man bekommt erstmal nichts von dem Fehler mit.

Der "best practise" Weg ist eine Exception im Konstruktor zu werfen. Wenn das passiert, wird das Objekt automatisch wieder aufgeräumt und der Ersteller bekommt eine deutliche Warnung

[Zacherl]

Da kann man sicherlich geteilter Meinung sein. Ich persönlich mag Klassen, die in ihren Methoden Exceptions werfen absolut nicht. Ich meine normalerweise würde man folgendes machen:

Delphi-Quellcode:

var
  Container: TContainer;
begin
  Containter := TContainer.Create(FileName);
  try
    if not Container.InvalidFile then
    begin

    end;
  finally
    Container.Free;
  end;
end;

Einen spezifischen Fehlercode kann man zur not auch noch irgendwo hinterlegen.

[DelphiNerd84]

wow, vielen dank für die schnellen antworten! habe schon befürchtet, dass man im constructor nicht gleich wieder den destructor aufrufen darf.. wäre auch zu schön gewesen! werde wohl den code auf mehrere blöcke aufteilen müssen, ähnlich Zacherl es vorgeschlagen hat. ein problem bleibt dennoch: wie kann ich herausfinden ob eine klasse noch existiert? sir rufo sagte bereits, dass das Zerstören die Referenzen nicht auf nil setzt! somit dürfte ja folgendes beispiel NICHT funktionieren..

Delphi-Quellcode:

var
  pFolder:Array Of ^TFolder;

Procedure RemoveFolder(Index:Integer;Recurse:Boolean);
Begin
 //TFolder(pFolder[Index]).DeleteChilds...
 TFolder(pFolder[Index]).Destroy;
End;

und dann später..

Procedure UpdateListItems;
var
  i:Integer;
Begin
 For i:=0To Pred(Length(pFolder))Do
  If TFolder(pFolder[i])=NIL Then RemoveListItem
End;

..aber wie kann ich dann mittels eines Pointers der auf eine Klasse verweist herausfinden ob diese überhaupt noch existiert (ohne eine exception aufzurufen)? naja werde mich wohl oder übel eingehender mit pointer, klassen etc. beschäftigen müssen danke für eure geduld

[Sir Rufo]

Du könntest aber auch eine class function bemühen, die dir ein entsprechendes Objekt zurückliefest oder eben nicht (nil)

[mkinzler]

Dann halt statt

Delphi-Quellcode:

  finally
    Container.Free;
  end;

Delphi-Quellcode:

  finally
    FreeAndNil( Container);
  end;

Btw nie Destroy direkt aufrufen
Zudem würde ich statt eines arrays eine Liste verwenden

[jfheins]

Zitat von Zacherl:

Da kann man sicherlich geteilter Meinung sein. Ich persönlich mag Klassen, die in ihren Methoden Exceptions werfen absolut nicht. Ich meine normalerweise würde man folgendes machen:

Delphi-Quellcode:

var
  Container: TContainer;
begin
  Containter := TContainer.Create(FileName);
  try
    if not Container.InvalidFile then
    begin

    end;
  finally
    Container.Free;
  end;
end;

Einen spezifischen Fehlercode kann man zur not auch noch irgendwo hinterlegen.

OMG

Zuerst zu dem Fehlercode: Das läuft auf das Gleiche hinaus wie die Property. Man kann sie ignorieren. Und das ist nicht gut. Unter anderem aus diesem Grund gibt es ja gerade die Exceptions, damit nicht jede Klasse ihren eigenen Fehlermechanismus implementieren muss.

Das zweite: Man lässt den Code einfach mal laufen und guckt dann nachher, ob es einen Fehler gegeben hat. Warum nicht vorher prüfen?

Delphi-Quellcode:

var
  Container: TContainer;
begin
   if Fileexists(FileName) then
   begin
      Containter := TContainer.Create(FileName);
      try
         //Was machen
      finally
         Container.Free;
      end;
   end;
end;

Falls die Prüfung vorher tatsächlich nicht gewünscht ist, geht immer noch das hier:

Delphi-Quellcode:

try
   Containter := TContainer.Create(FileName);
except end;

  If Containter=NIL Then 
    ShowMessage('Containter is NIL')
   Else 
    ShowMessage('Containter is NOT NIL');
   Containter.DoSomething; //..erzeugt Exception!

Wenn der Konstruktor eine Exception wirft, wird die Variable nicht verändert - bleibt also nil.
Der Zugriff am Ende erzeugt aber immer noch eine AV.

[DelphiNerd84]

es funzt! keine ahnung ob des professionell gelöst ist, aber es geht erstmal

Delphi-Quellcode:

UNIT UContainer;
INTERFACE
USES
  SysUtils;
VAR
  pSelf:Pointer;
TYPE
  TContainer=Class
    Private
      FFileName:String;
      //pLevel:Arary Of ^TLevel;
      //Procedure HandleFile;
      //..
    Public
      Class Function Alive:Boolean;
      Constructor Create;
      Destructor Destroy;override;
      Procedure Assign(const FName:String;AsReadOnly:Boolean);
      Property FileName:String Read FFileName;
      //..
  End;
IMPLEMENTATION
Class Function TContainer.Alive:Boolean;
Begin
 Result:=pSelf<>NIL
End;
Constructor TContainer.Create;
Begin
 inherited Create;
 pSelf:=Pointer(Self);
 //..
End;
Destructor TContainer.Destroy;
Begin
 //..
 pSelf:=NIL;
 inherited Destroy
End;
Procedure TContainer.Assign(const FName:String;AsReadOnly:Boolean);
Begin
 If Not FileExists(FName)Then Begin
  //Destroy
  Free
 End
End;
END.

Delphi-Quellcode:

var
  P:Pointer;
Begin
 P:=TContainer.Create;
 TContainer(P).Assign('C:\Non-Existing-File.txt',False);
 If NOT TContainer(P).Alive Then Begin
  ShowMessage('Klasse existiert nicht mehr!');
  P:=NIL
 End
End;

Danke an alle! und gute n8

[Zacherl]

Wie gesagt Geschmackssache. Angenommen die Prüfung gestaltet sich nicht so einfach, wie das Prüfen auf Vorhandensein einer Datei. Eine Exception wird im Constructor geworfen. Dann sieht der Quelltext schon extrem unübersichtlich aus:

Delphi-Quellcode:

var
  Container: TContainer;
begin
  try
    Containter := TContainer.Create(FileName);
    try
      // Hier mache ich was  
    finally
      Container.Free;
    end;
  except
    // Hier ging was schief
  end;
end;