delphi - Cómo escribir correctamente Try..Finally... Except statements?

delphi try except finally

Question

Tome el siguiente código como muestra:

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;

si ocurriera un error en la sección // do something , el TSomeObject creado, supongo, no se liberará y Screen.Cursor seguirá bloqueado como Hour Glass, porque el código estaba roto antes de llegar a esas líneas.

Ahora, a menos que esté confundiendo, debería existir una declaración de Excepción para tratar cualquier ocurrencia de un error, algo así como:

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;

Ahora, a menos que esté haciendo algo realmente estúpido, no debería haber ninguna razón para tener el mismo código dos veces en el bloque Finally y después, y en el bloque Exception.

Básicamente, a veces tengo algunos procedimientos que pueden ser similares a la primera muestra que publiqué, y si obtengo un error, el cursor se bloquea como un reloj de arena. Agregar los manejadores de excepciones ayuda, pero parece una manera sucia de hacerlo, básicamente ignorando el bloque Finally, sin mencionar el código feo con copy-paste de las partes de Finally to Exception.

Todavía estoy aprendiendo mucho acerca de Delphi, así que me disculpo si esto parece ser una pregunta / respuesta directa.

¿Cómo se debe escribir correctamente el código para manejar los enunciados y liberar correctamente objetos y capturar errores, etc.?

Answer 1

Como otros han explicado, debes proteger el cambio del cursor con try finally block. Para evitar escribir esos, uso un código como este:

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.

Ahora solo lo usa como

uses
   autoCursor;

procedure TForm1.Button1Click(Sender: TObject);
var
  Obj: TSomeObject;
begin
  __SetCursor(crHourGlass);

  Obj:= TSomeObject.Create;
  try
    // do something
  finally
    Obj.Free;
  end;
end;

y el mecanismo de interfaz contado de referencia de Delphi se encarga de restaurar el cursor.

Answer 2

Creo que la versión más "correcta" sería esta:

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;

Answer 3

Después de haber hecho un montón de código en servicios / servidores que necesitan manejar excepciones y no matar la aplicación, suelo buscar algo como esto:

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;

Tenga en cuenta el intento finalmente; dentro del intento excepto; y la colocación de la creación Obj.

si el Obj crea otras cosas dentro de su constructor, puede funcionar a mitad de camino y fallar con una excepción dentro de .create (); pero aún así ser un Obj creado. Así que me aseguro de que el Obj siempre se destruya si se ha asignado ...

Answer 4

Lo haría así:

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;

Answer 5

Solo necesitas dos bloques try/finally :

Screen.Cursor:= crHourGlass;
try
  Obj:= TSomeObject.Create;
  try
    // do something
  finally
    Obj.Free;
  end;
finally
  Screen.Cursor:= crDefault;
end;

La pauta a seguir es que debe usar finally lugar de, except para proteger recursos. Como ha observado, si intenta hacerlo con except entonces se ve obligado a escribir el código de finalización dos veces.

Una vez que ingrese el bloque try/finally , se garantiza que se ejecutará el código en la sección finally , sin importar qué ocurra entre try y finally .

Por lo tanto, en el código anterior, el try/finally externo try/finally asegura que Screen.Cursor se restaure ante cualquier excepción. Del mismo modo, el try/finally interno asegura que Obj se destruya en caso de que se Obj alguna excepción durante su vida útil.

Si desea manejar una excepción, necesita un bloque try/except distinto. Sin embargo, en la mayoría de los casos, no debe tratar de manejar excepciones. Simplemente permita que se propague al manejador principal de excepciones de la aplicación que mostrará un mensaje al usuario.

Si maneja la excepción para bajar la cadena de llamada, el código de llamada no sabrá que el código al que llamó ha fallado.

Answer 6

Tu código original no es tan malo como crees:

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 se ejecutará sin importar lo que ocurra cuando // do something . Incluso si ocurre una excepción (después de la try ), ¡se ejecutará el bloque finally ! Ese es el objetivo de la construcción de try..finally !

Pero también quieres restaurar el cursor. La forma más pedante es usar dos construcciones try..finally :

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;

[Sin embargo, tampoco me importaría

procedure TForm1.Button1Click(Sender: TObject);
var
  Obj: TSomeObject;
begin

  Obj := TSomeObject.Create;
  Screen.Cursor := crHourGlass;      
  try
    // do something
  finally
    Screen.Cursor := crDefault;      
    Obj.Free;
  end;

end;

demasiado. El riesgo de Screen.Cursor := crHourGlass falla es bastante bajo, pero en tal caso el objeto no se liberará (el finally no se ejecutará porque no estás dentro del try ), por lo que el doble try..finally es más seguro .]