How to correctly write Try..Finally..Except statements?
Take the following code as a sample:
procedure TForm1.Button1Click(Sender: TObject);
var
Obj: TSomeObject;
begin
Screen.Cursor:= crHourGlass;
Obj:= TSomeObject.Create;
try
// do something
finally
Obj.Free;
end;
Screen.Cursor:= crDefault;
end;
if there was an error happening in the // do something
section, the TSomeObject that was created I assume will not be freed and the Screen.Cursor will still be stuck as an Hour Glass, because the code was broke before getting to those lines?
Now unless I am mistaking, an Exception statement should be in place to deal with any such occurence of an error, something like:
procedure TForm1.Button1Click(Sender: TObject);
var
Obj: TSomeObject;
begin
try
Screen.Cursor:= crHourGlass;
Obj:= TSomeObject.Create;
try
// do something
finally
Obj.Free;
end;
Screen.Cursor:= crDefault;
except on E: Exception do
begin
Obj.Free;
Screen.Cursor:= crDefault;
ShowMessage('There was an error: ' + E.Message);
end;
end;
Now unless I am doing something really stupid, there should be no reason to have the same code twice in the Finally block and after, and in the Exception block.
Basically I sometimes have some procedures that may be similar to the first sample I posted, and if I get an 开发者_JAVA百科error the cursor is stuck as an Hour Glass. Adding the Exception handlers help, but it seems a dirty way of doing it - its basically ignoring the Finally block, not to mention ugly code with copy-paste from the Finally to Exception parts.
I am still very much learning Delphi so apologies if this appears to be a straight forward question/answer.
How should the code be correctly written to deal with the Statements and correctly freeing objects and capturing errors etc?
You just need two try/finally
blocks:
Screen.Cursor:= crHourGlass;
try
Obj:= TSomeObject.Create;
try
// do something
finally
Obj.Free;
end;
finally
Screen.Cursor:= crDefault;
end;
The guideline to follow is that you should use finally
rather than except
for protecting resources. As you have observed, if you attempt to do it with except
then you are forced to write the finalising code twice.
Once you enter the try/finally
block, the code in the finally
section is guaranteed to run, no matter what happens between try
and finally
.
So, in the code above, the outer try/finally
ensures that Screen.Cursor
is restored in the face of any exceptions. Likewise the inner try/finally
ensures that Obj
is destroyed in case of any exceptions being raised during its lifetime.
If you want to handle an exception then you need a distinct try/except
block. However, in most cases you should not attempt to handle exceptions. Just let it propagate up to the main application exception handler which will show a message to the user.
If you handle the exception to low down the call chain then the calling code will not know that the code it called has failed.
Your original code isn't quite as bad as you think (it's bad, though):
procedure TForm1.Button1Click(Sender: TObject);
var
Obj: TSomeObject;
begin
Screen.Cursor := crHourGlass;
Obj := TSomeObject.Create;
try
// do something
finally
Obj.Free;
end;
Screen.Cursor := crDefault;
end;
Obj.Free
will be executed no matter what happens when you // do something
. Even if an exception occurrs (after try
), the finally
block will be executed! That is the whole point of the try..finally
construct!
But you also want to restore the cursor. The best way is to use two try..finally
constructs:
procedure TForm1.Button1Click(Sender: TObject);
var
Obj: TSomeObject;
begin
Screen.Cursor := crHourGlass;
try
Obj := TSomeObject.Create;
try
// do something
finally
Obj.Free;
end;
finally
Screen.Cursor := crDefault;
end;
end;
As others have explained, you need to protect the cursor change with try finally
block. To avoid writing those I use code like this:
unit autoCursor;
interface
uses Controls;
type
ICursor = interface(IInterface)
['{F5B4EB9C-6B74-42A3-B3DC-5068CCCBDA7A}']
end;
function __SetCursor(const aCursor: TCursor): ICursor;
implementation
uses Forms;
type
TAutoCursor = class(TInterfacedObject, ICursor)
private
FCursor: TCursor;
public
constructor Create(const aCursor: TCursor);
destructor Destroy; override;
end;
{ TAutoCursor }
constructor TAutoCursor.Create(const aCursor: TCursor);
begin
inherited Create;
FCursor := Screen.Cursor;
Screen.Cursor := aCursor;
end;
destructor TAutoCursor.Destroy;
begin
Screen.Cursor := FCursor;
inherited;
end;
function __SetCursor(const aCursor: TCursor): ICursor;
begin
Result := TAutoCursor.Create(aCursor);
end;
end.
Now you just use it like
uses
autoCursor;
procedure TForm1.Button1Click(Sender: TObject);
var
Obj: TSomeObject;
begin
__SetCursor(crHourGlass);
Obj:= TSomeObject.Create;
try
// do something
finally
Obj.Free;
end;
end;
and Delphi's reference counted interface mechanism takes care of restoring the cursor.
I think the most "correct" version would be this:
procedure TForm1.Button1Click(Sender: TObject);
var
Obj: TSomeObject;
begin
Obj := NIL;
Screen.Cursor := crHourGlass;
try
Obj := TSomeObject.Create;
// do something
finally
Screen.Cursor := crDefault;
Obj.Free;
end;
end;
Having done a lot of code in services/servers that needs to handle exceptions and not kill the app I usually go for something like this:
procedure TForm1.Button1Click(Sender: TObject);
var
Obj: TSomeObject;
begin
try
Obj := NIL;
try
Screen.Cursor := crHourGlass;
Obj := TSomeObject.Create;
// do something
finally
Screen.Cursor := crDefault;
if assigned(Obj) then FreeAndNil(Obj);
end;
except
On E: Exception do ; // Log the exception
end;
end;
Note the try finally; inside the try except; and the placement of Obj creation.
if the Obj creates other things inside it's constructor, it may work half-way and fail with an exception inside the .create(); but still be a created Obj. So I make sure that the Obj is always destroyed if it's been assigned...
I would do it like this:
var
savedCursor: TCursor;
Obj: TSomeObject;
begin
savedCursor := Screen.Cursor;
Screen.Cursor := crHourGlass;
Obj:= TSomeObject.Create;
try
try
// do something
except
// record the exception
end;
finally
if Assigned(Obj) then
Obj.Free;
Screen.Cursor := savedCursor;
end;
end;
If you found your way here and were looking for how you make a try-except-finally
construct from C# in Delphi:
// C#
try
{
// Do something
}
catch
{
// Exception!
}
finally
{
// Always do this...
}
The answer is that you cannot do this directly. Instead, as @sacconago hints at, nest the try
blocks as follows:
// Delphi
try
try
// Do something
except
// Exception!
end;
finally
// Always do this...
end;
One nice feature of Delphi is that you can nest the blocks as try...except...finally
or try...finally...except
, though the former would be more common.
精彩评论