catch - manejo de excepciones en delphi

¿Cómo debo volver a plantear una excepción de Delphi después de iniciar sesión?

Question

¿Conoces una forma de atrapar, registrar y volver a subir la excepción en el código Delphi? Un simple ejemplo:

procedure TForm3.Button1Click(Sender: TObject);
begin
  try
    raise Exception.Create(''Bum'');
  except
    on E: Exception do
    begin
      MyHandleException(E);
    end;
  end;
end;

procedure TForm3.MyHandleException(AException: Exception);
begin
  ShowMessage(AException.Message);
  LogThis(AException.Message);  
  // raise AException; - this will access violate
end;

Así que tengo que volver a subirlo en el bloque excepto, pero me preguntaba si hay una mejor manera de escribir mi propio método para manejar y (en condiciones específicas) volver a plantear excepciones.

Answer 1

Debería poder usar el comando Raise solo para volver a subir la excepción:

begin
  MyHandleException(E);
  Raise;
end;

Answer 2

Lo siguiente funcionará, pero por supuesto no es ideal por dos razones:

• La excepción se plantea desde un lugar diferente en la pila de llamadas.
• No obtiene una copia exacta de la excepción, especialmente aquellas clases que agregan atributos. Es decir, tendrá que copiar explícitamente los atributos que necesita.
• La copia de atributos personalizados puede complicarse debido a la verificación de tipos requerida.

.

procedure TForm3.MyHandleException(AException: Exception);
begin
  ShowMessage(AException.Message);
  LogThis(AException.Message);  
  raise ExceptClass(AException.ClassType).Create(AException.Message);
end;

Los beneficios son que conserva la clase de excepción original y el mensaje (y cualquier otro atributo que desee copiar).

Lo ideal es llamar a System._RaiseAgain , pero, por desgracia, es una rutina de "compilación mágica" y solo se puede llamar mediante raise; .

Answer 3

Puede adquirir el objeto de excepción antes de llamar a su controlador y mantener el controlador en sí mismo un liner. Sin embargo, todavía tiene una gran cantidad de carga "Try / Except / Do / End".

Procedure MyExceptionHandler(AException: Exception);
Begin
  Log(AException); // assuming it accepts an exception
  ShowMessage(AException.Message);
  raise AException; // the ref count will be leveled if you always raise it
End;

Procedure TForm3.Button1Click(Sender: TObject);
Begin
  Try
    Foo;
  Except On E:Exception Do
    MyExceptionHandler(Exception(AcquireExceptionObject));
  End;
End;

Sin embargo, si lo único que desea hacer es deshacerse del código de manejo de errores repetitivo en los controladores de eventos, podría intentar esto:

Procedure TForm3.ShowException(AProc : TProc);
Begin
  Try
    AProc;
  Except On E:Exception Do Begin
    Log(E);
    ShowMessage(E.Message);
  End; End;
End;

Reduciendo su código de controlador de eventos a esto:

Procedure TForm3.Button1Click(Sender: TObject);
Begin
  ShowException(Procedure Begin // anon method
    Foo; // if this call raises an exception, it will be handled by ShowException''s handler
  End);
End;

También puede hacer que funcione para funciones, usando funciones parametrizadas:

Function TForm3.ShowException<T>(AFunc : TFunc<T>) : T;
Begin
  Try
    Result := AFunc;
  Except On E:Exception Do Begin
    Log(E);
    ShowMessage(E.Message);
  End; End;
End;

Y hacer que ShowException devuelva un valor (actuando como un passthru):

Procedure TForm3.Button1Click(Sender: TObject);
Var
  V : Integer;
Begin
  V := ShowException<Integer>(Function : Integer Begin // anon method
    Result := Foo; // if this call raises an exception, it will be handled by ShowException''s handler
  End);
End;

O incluso haciendo que el procedimiento anon toque directamente la (s) variable (s) del ámbito externo:

Procedure TForm3.Button1Click(Sender: TObject);
Var
  V : Integer;
Begin
  ShowException(Procedure Begin // anon method
    V := Foo; // if this call raises an exception, it will be handled by ShowException''s handler
  End);
End;

Existen algunas limitaciones en la interacción de variables desde el interior del cuerpo de la función anónima y las definidas en el ámbito externo, pero para casos simples como estos, estará más que bien.

Answer 4

Puede intentar usar (system.pas):

function AcquireExceptionObject: Pointer;

AcquireExceptionObject devuelve un puntero al objeto de excepción actual y evita que el objeto de excepción sea desasignado cuando se cierra el controlador de excepción actual.

Nota: AcquireExceptionObject incrementa el recuento de referencias del objeto de excepción. Asegúrese de que el recuento de referencias disminuya cuando ya no se necesite el objeto de excepción. Esto sucede automáticamente si usa el objeto de excepción para volver a generar la excepción. En todos los demás casos, cada llamada a AcquireExceptionObject debe tener una llamada correspondiente a ReleaseExceptionObject. Las secuencias de AcquireExceptionObject / ReleaseExceptionObject se pueden anidar.

Answer 5

Si desea volver a plantear la excepción solo bajo ciertas condiciones, escriba

procedure TForm3.Button1Click(Sender: TObject);
begin
  try
    raise Exception.Create(''Bum'');
  except
    on E: Exception do
    begin
      if MyHandleException(E) then
        raise;
    end;
  end;
end;

function TForm3.MyHandleException(AException: Exception): boolean;
begin
  ShowMessage(AException.Message);
  result := true/false;
end;

Answer 6

Siguiendo con la publicación de Craig Young, utilicé algo similar al siguiente código con éxito. Puede conservar la ubicación de excepción original utilizando el identificador "at" con la función ExceptAddr. El tipo de clase de excepción original y la información también se conservan.

procedure MyHandleException(AMethod: string);
var
  e: Exception;
begin
  e := Exception(AcquireExceptionObject);
  e.Message := e.Message + '' raised in '' + AMethod; 
  raise e at ExceptAddr;
end;

try
  ...
except
  MyHandleException(''MyMethod'');
end;

Answer 7

Viejo tema pero, ¿qué pasa con esta solución?

procedure MyHandleException(AException: Exception);
begin
  ShowMessage(AException.Message);
  AcquireExceptionObject;
  raise AException;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  try
    raise Exception.Create(''Bum'');
  except
    on E: Exception do
      MyHandleException(E);
  end;
end;

Se basa en el primer código publicado por Eduardo.