try-try-finally-finally

[[Al González]]

Empezado por roman

...En la segunda forma, la compacta, si hay un error durante la creación del objeto A, el código del finally se ejecutará indistintamente, lo cual incluye la llamada al método Free de ObjetoB, y esto podría ser un problema, si la variable ObjetoB no está inicializada -según recuerdo, las variables locales no necesariamente se inicializan en automático, así que ObjetoB podría no ser nil...

Y también aunque se tratara de una variable global, ya que ObjetoB podría tener el vestigio (la dirección de memoria) de una instancia que previamente le fue asignada y luego destruida. De ahí que en algunos casos se recomiende el uso de FreeAndNil.

Empezado por roman

Y bueno, al parecer las formas realmente equivalentes son estas:

Forma anidada:

Código Delphi [-]
 
var
  A: TObjetoA;
  B: TObjetoB;
begin
  A := TObjetoA.Create;
 
  try
    B := TObjetoB.Create;
 
    try
 
      { algo de código }
 
    finally
      B.Free;
    end;
  finally
    A.Free;
  end;
end;

Forma compacta:

Código Delphi [-]
 
var
  A: TObjetoA;
  B: TObjetoB;
 
begin
  A := nil;
  B := nil;
  A := TObjetoA.Create;
  B := TObjetoB.Create;

  try
    // esto lo moví arriba del Try.  Al.
{    A := TObjetoA.Create;
    B := TObjetoB.Create;}
 
    { algo de código }
 
  finally
    A.Free;
    B.Free;
  end;
end;

...así, el compilador no genera ningún warning [advertencia]...

Eso te iba a comentar, Román, tras leer el primer mensaje del hilo. El "cierre" que se hace dentro de un Finally debe corresponder a la "apertura" hecha justo (o casi justo) antes del Try.

El problema de la versión compacta es que no ofrece seguridad para destruir el objeto B. Si la sentencia "A.Free;" eleva una excepción (como sabes, también al destruir objetos suelen ocurrir excepciones), la rutina se romperá en ese punto y el programa no alcanzará a ejecutar la sentencia "B.Free;", quedando un objeto ocupando memoria inútilmente. En cambio, con la versión anidada, el programa destruirá a cada uno de los objetos instanciados, independientemente de lo que suceda durante el uso de los mismos.

Oye Román, ¿no será que Embarcadero te encargó reclutar programadores planteando estas cuestiones tan interesantes?

Saludos.

Al González.

EDITO: Román: Me tomé la libertad de cambiar algo en el código del texto donde te cito, ya que al parecer no estaba corregido del todo. Asumo que en realidad lo querías escribir como ahora lo he dejado.

[roman]

cHackAll, creo que olvidas dos puntos importantes.

Primero, que las inicializaciones a nil en el caso compacto, son esenciales, y segundo, que se recomienda usar Free en lugar de Destroy precisamente porque nil.Free no produce una violación de acceso tal como sí lo hace nil.Destroy.

Haciéndolo así, evitas justamente la nueva excepción que mencionas en tu caso compacto.

Pero por otra parte, hay que notar que la (posible) diferencia entre el caso anidado y el compacto, en los casos que se describen, radica -justamente- en una eventual excepción dentro de un constructor, por lo que no veo el por qué de "sacar" la excepción del constructor.

Vamos a ver si lo aclaramos.

En ambos casos, el objetivo es no dejar ningún objeto sin destruir. El caso anidado es claro que lo cumple por el argumento que esgrime seoane (a fin de cuentas, tiene que ser cierto, o nos han mentido todos estos años )

Veamos el caso compacto, tal como lo escribí luego de corregirme a mi mismo:

Código Delphi [-]
var
  A: TObjetoA;
  B: TObjetoB;

begin
  A := nil;
  B := nil;

  try
    A := TObjetoA.Create;
    B := TObjetoB.Create;

    { algo de código }

  finally
    A.Free;
    B.Free;
  end;
end;

Por supuesto que en la parte que dice

Código Delphi [-]
{ algo de codigo }

puede ocurrir cualquier cosa, pero para entonces ya ambos objetos, A y B han sido construidos exitosamente, de manera que ambos son referencias válidas. Si en el resto de código ocurre algo, el finally se ejecutará sí o sí, asegurando la destrucción de ambos objetos.

Por ellos es que el problema en sí, se da cuando uno de los constructores presente una excepción; si "sacamos" la excepción del constructor, estamos en el caso recién descrito.

Si el constructor de A genera una excepción, la línea

Código Delphi [-]
B := TObjetoB.Create;

nunca se ejecutará, de manera que ni A ni B serán referencias válidas. ¿No?

Incorrecto, porque ambas son nil desde un principio por lo que las llamadas a Free no provocan ningún nuevo error.

Si A se construye exitosamente y el constructor de B genera una excepción, estamos igual de seguros. A.Free no tiene problemas, pero tampoco B.Free pues B se inicializó a nil y Free puede usarse en ese caso.

// Saludos

[dec]

Hola,

Tal vez es que estamos poniendo demasiado énfasis en la liberación de los objetos, cuando quizá el "finally" podría ser también aprovechado para otras cuestiones. Por tanto, no es que nos interese llegar a "finally" con el objeto "válido" o "nil", sino válido en todo caso, puesto que no podremos hacer lo que acaso necesitemos, además de liberar el objeto. En definitiva, igual es que resulta complicado una especie de "plantilla" sobre cómo actuar, sino que dependerá de la situación, ¿no?

[roman]

Empezado por dec

Hola,

Tal vez es que estamos poniendo demasiado énfasis en la liberación de los objetos, cuando quizá el "finally" podría ser también aprovechado para otras cuestiones. Por tanto, no es que nos interese llegar a "finally" con el objeto "válido" o "nil", sino válido en todo caso, puesto que no podremos hacer lo que acaso necesitemos, además de liberar el objeto. En definitiva, igual es que resulta complicado una especie de "plantilla" sobre cómo actuar, sino que dependerá de la situación, ¿no?

Pues no sé David, para mi (y esto obviamente es muy subjetivo) lo esencial era simplemente ver si ante la necesidad de construir dos o más objetos, es posible asegurar la correcta destrucción sin necesidad de un nivel de anidación por cada objeto construido, que me parece muy confuso.

Hasta donde alcanzo a ver, sí es posible, siempre y cuando inicialicemos a nil todas las variables.

// Saludos

[[Delphius]]

Hola disculpen que me meta donde no me llamen, no se si se deba a que estoy un tanto dormido, pero no termino de comprender a lo que se desea llegar.

No conozco demasiado, pero tengo entendido que una máxima de la programación dice "un objeto o se crea o no crea, no puede ser creado a medias". Si ocurre un error durante la creación de un objeto tiene lugar el evento destructor para limpiar la memoria, por tanto quedará la variable quedará apuntando a nil.

Tengo entendido, por favor corrijanme o tirenme de la oreja si me equivoco, que el método create no provoca ninguna excepción por lo que incorporar la sentencia

Código Delphi [-]
ObjA := TObjA.Create;

dentro de un Try está demás. No puede esperarse capturar una excepción en Create, más bien se puede capturar cuando se desea hacer uso de algún método y/o acceder a una propiedad.

De modo que la excepción que obtendremos es ese famoso EAccessViolation. En síntesis, yo lo veo así:

Código Delphi [-]
objA := TObjA.Create;
try
    ObjtA...
    ...
except
    on E: EAccessViolation do
        ShowMessage('¡Hey, Obj no ha sido creado!);
end;

Repito nuevamente, no se si es eso lo que se trata de ver aqui. La verdad es que me sentí un tanto confundido cuando leía este hilo. Mas yo posteo aqui por curiosidad y por un tirón de orejas para ver si logro aprender el tema que se está debatiendo.

Saludos,

[[coso]]

Hola, solo una duda

Código Delphi [-]
var
  A: TObjetoA;
  B: TObjetoB;

begin
  A := nil;
  B := nil;

  try
    A := TObjetoA.Create;
    B := TObjetoB.Create;

    { algo de código }

  finally
    A.Free;
    B.Free;
 end;

¿porque esta asignación? ¿si falla el create, o incluso si no llega, no estan apuntando A y B a 0x0000 desde el principio?


PD : Vale, ahora lo lei... claro esta que con freemem(A) no harian falta. No, tampoco funciona si que se tiene que asignar.

[[seoane]]

Pues a mi las dos construcciones que pone roman en el post numero 11 me parecen correctas. Yo escogeria siempre la primera, sobre todo porque estoy mas acostumbrado a hacerlo así, pero ambas son tecnicamente correctas.

Solo aclarar un par de cosas:

• El metodo create de un objeto puede provocar una excepcion (Por ejemplo un TFileStream con un nombre de archivo incorrecto)
• Si el metodo Create provoca una excepcion devuleve nil y el metodo destroy del objeto es llamado automaticamente.

En resumen, si me dan a escoger, yo escojo la primera forma. Pero si tengo que crear 20 objetos juntos no dudaria en usar la segunda forma que expone roman.

[roman]

Al, las líneas que moviste, de hecho, es esencial que permanezcan donde estaban

Si lees lo que comenté a Javier, verás que el problema real radica en las excepciones que se generan en el constructor. Al mover la construcción de los objetos fuera del bloque try-finally-end, impides, por ejemplo, la liberación de A en caso de una excepción en el constructor de B.

Cuando sólo estamos interesados en un objeto, el esquema usual:

Código Delphi [-]
A := TObjetoA.Create;

try
  { algo de código }
finally
  A.Free;
end;

es totalmente válido, pues, si A.Create genera una excepción, no hay, de hecho, ninguna asignación y, por ende, ninguna necesidad de llamar a Free (*).

Pero nota, de hecho, que este esquema es equivalente a:

Código Delphi [-]
A := nil;

try
  A := TObjetoA.Create;

  { algo de código }
finally
  A.Free;
end;

Aunque aquí, la llamada a A.Free (protegida por la inicialización a nil) es innecesaria (A nunca se construye). Pero es este esquema el que nos serviría en el caso de más objetos si deseamos evitar las anidaciones.

Ahora, en cuanto a

Empezado por Al González

El problema de la versión compacta es que no ofrece seguridad para destruir el objeto B. Si la sentencia "A.Free;" eleva una excepción (como sabes, también al destruir objetos suelen ocurrir excepciones), la rutina se romperá en ese punto y el programa no alcanzará a ejecutar la sentencia "B.Free;", quedando un objeto ocupando memoria inútilmente

entramos en un terreno peliagudo. Hasta donde yo he visto en los grupos de Borland (que es de dónde saqué inicialmente estas cuestiones) es, por el contrario, sumamente raro ver una excepción en un destructor. Uno puede asumir que no habrá excepciones. De lo contrario tendríamos que proteger cada llamada al destructor, incluida la del inherited en la implementación de nuestro propio Destroy:

Código Delphi [-]
destructor TObjetoA.Destroy;
begin
  try
    { código destructor que posiblemente genere una excepción }
  finally
    inherited
  end;
end;

Sin esa protección, el destructor de la clase ancestra no se ejecutaría. Por ello es que un destructor no o no debe producir una excepción.

(*) No obstante, aquí surge otra cuestión interesante:

Si el constructor de un objeto genera una excepción, el objeto no termina de construirse, pero es muy posible que ya haya asignado recursos, por ejemplo, al invocar al constructor de la clase ancestra:

Código Delphi [-]
constructor TObjetoA.Create;
begin
  inherited;

  { código que posiblemente genere una excepción }
end;

¿El destructor de la clase ancestra es invcado en automático?

// Saludos

[[Al González]]

¡Hola!

Empezado por roman

Al, las líneas que moviste, de hecho, es esencial que permanezcan donde estaban ...

Bueno, es que de hecho ninguna de las variantes expuestas de la forma compacta son más seguras y válidas que la forma anidada.

Sólo que pensé que deseabas escribir la forma compacta al estilo de la forma anidada.

Desde luego que hay mucha lógica en lo que dices, pero como mencioné antes:

Empezado por Al González

...El problema de la versión compacta es que no ofrece seguridad para destruir el objeto B. Si la sentencia "A.Free;" eleva una excepción, la rutina se romperá en ese punto y el programa no alcanzará a ejecutar la sentencia "B.Free;", quedando un objeto ocupando memoria inútilmente. En cambio, con la versión anidada, el programa destruirá a cada uno de los objetos instanciados, independientemente de lo que suceda durante el uso de los mismos...

Ante lo cual argumentas que:

Empezado por roman

...entramos en un terreno peliagudo. Hasta donde yo he visto en los grupos de Borland (que es de dónde saqué inicialmente estas cuestiones) es, por el contrario, sumamente raro ver una excepción en un destructor. Uno puede asumir que no habrá excepciones. De lo contrario tendríamos que proteger cada llamada al destructor, incluida la del inherited en la implementación de nuestro propio Destroy...

Razonamiento que también me parece lógico, pero no del todo válido. Es decir, creo que depende de cada situación en particular. En ocasiones podremos asumir que no habrá excepción alguna al liberar un objeto, por realizar su destructor un trabajo relativamente fácil. Pero indudablemente que en otras ocasiones preferiremos la forma anidada por ser indiscutiblemente más segura.

En concreto, creo que siempre estaré inclinado a usar la forma anidada, como lo hizo Borland en esta parte de la unidad AxCtrls.pas de Delphi 7:

Código Delphi [-]
var
  OleStream: TOleStream;
  Writer: TWriter;
begin
  OleStream := TOleStream.Create(Stream);
  try
    Writer := TWriter.Create(OleStream, 4096);
    try
      Writer.IgnoreChildren := True;
      Writer.WriteDescendent(FControl, nil);
    finally
      Writer.Free;
    end;
  finally
    OleStream.Free;
  end;

Aunque probablemente utilice la forma compacta en algunas ocasiones (por confiar en que la primera destrucción no elevará una excepción), como confió Borland en esta parte de la unidad Buttons.pas:

Código Delphi [-]
var
  TmpImage, DDB, MonoBmp: TBitmap;
  ...
begin
  ...
          MonoBmp := nil;
          DDB := nil;
          try
            MonoBmp := TBitmap.Create;
            DDB := TBitmap.Create;
            ...
          finally
            DDB.Free;
            MonoBmp.Free;
          end;

Pero además, si para algunas situaciones se vale asumir que un destructor no elevará excepción alguna, entonces el mismo criterio podría ser aplicado a un constructor, como lo hizo Borland en esta parte de ComCtrls.pas:

Código Delphi [-]
var
  ...
  LSelect, LDeselect: TList;
  ...
begin
  ...
    LSelect := TList.Create;
    LDeselect := TList.Create;
    try
      ...
    finally
      LDeselect.Free;
      LSelect.Free;
    end;

En conclusión, hay tres formas de hacerlo:
1. Anidada con un Try-Finally por instanciación.
2. Compacta con asignación de Nil antes del Try e instanciaciones dentro del Try.
3. Compacta con las instanciaciones antes del Try.

¿Cuál es la más segura? La 1.

¿Cuál es la más correcta? Depende de cada caso y del criterio aplicado.

Empezado por roman

...surge otra cuestión interesante: Si el constructor de un objeto genera una excepción, el objeto no termina de construirse, pero es muy posible que ya haya asignado recursos, por ejemplo, al invocar al constructor de la clase ancestra:

¿El destructor de la clase ancestra es invcado en automático? ...

Muy buena pregunta, Román. Desde que leí esta parte de la ayuda de Delphi, hace ya muchos años:

Empezado por Borland

...If an exception is raised during execution of a constructor that was invoked on a class reference, the Destroy destructor is automatically called to destroy the unfinished object...

entendí que el destructor al que llama Delphi es al de la misma clase que utilizas para crear la instancia. El cual, se entiende, llama a su vez al destructor de sus clases ancestro.

No sé si tu inquietud va por el lado de que la elevación de una excepción en ese punto debería causar una llamada directa al destructor heredado, pero es más adecuado que llame al destructor de la propia clase usada para la construcción, ya que así se asegura la liberación de cualquier recurso que el constructor haya alcanzado a asignar. Recordemos que al crear una instancia ésta se inicializa en blanco (ceros) antes de ejecutarse el constructor, así que no hay problema de que el destructor intente algunas liberaciones al estilo "FX.Free" con campos que nunca alcanzaron a tomar un recurso asignado.

Muy interesantes planteamientos, Román.

Saludos.

Al.

[roman]

Empezado por Al González

Bueno, es que de hecho ninguna de las variantes expuestas de la forma compacta son más seguras y válidas que la forma anidada.

De hecho, la forma que he expuesto ya varias veces, con las líneas donde deben ir, es igual de segura y válida. Si vuelves a leer, verás que las asignaciones a nil se hacen en un lugar preciso y no al azar o por un mero deseo de escribirlo de una u otra forma. Los ejemplos que muestras del código de VCL ejemplifican, de hecho, la validez de ambas opciones.

Cuando se dice: es raro que un destructor genere una excepción, no es sólo que sea algo difícil porque lo que ahí se hace es muy fácil. Es que, como ya mencioné, si un destructor genera una excepción, el objeto no se destruirá correctamente, y es un error -muy grave- que habría que corregir antes siquiera de preocuparse por que el objeto siguiente no se destruya.

// Saludos

[[Al González]]

Las tres formas son válidas, Román, dependiendo de cada caso y criterio. Como ya lo expuse.

No dije que la forma compacta fuera categóricamente inválida. Creo que en este punto de la discusión sería prudente invitarnos a aceptar que las tres formas son válidas, pero cada una dependiendo del contexto, como mencioné antes. Los tres ejemplos que puse ejemplifican que Borland así lo ha concluido también, y creo que pueden servir, junto con el resto del hilo, como una buena referencia para otros compañeros del club.

Un abrazo.

Al.

[roman]

De hecho, yo sé que ambas son válidas desde el mensaje 11. Y, en verdad, no creo que dependa de ningún contexto, sino del gusto de cada quien. Y lo enfatizo porque creo que esto es lo que puede servir de guía a futuro. De lo contrario, habrá que especificar con detalles en qué consiste cada contexto para saber cuándo es aplicable una u otra forma.

// Saludos

[[Caral]]

Hola

Empezado por Al González

.... y creo que pueden servir, junto con el resto del hilo, como una buena referencia para otros compañeros del club.

Y yo agregaría que nos habéis dado una cátedra que hace tiempo no veía en el club.
Ojala se repitan dudas como esta en donde los maestros exponen sus criterios y los Novatos miran, callan y aprenden.
Gracias Señores.
Saludos