Un breve análisis de problemas comunes en las excepciones y protección de transacciones de DELPHI

1. Método de salida

Originalmente pensé que el proceso saldría inmediatamente después de que se ejecutara el método Exit, pero cambié de opinión después de hacer un ejemplo para probarlo. Por favor mira esto

Por ejemplo, a la bandera finalmente se le asigna el valor 'C'.

==================================================== =================================================

var

bandera: cadena;

comenzar

intentar

bandera := 'A';

Salida;

bandera := 'B';

finalmente

bandera := 'C';

fin;

bandera := 'D';

fin;

==================================================== =================================================

Análisis: No importa cómo termine la cláusula try, la cláusula finalmente siempre se ejecuta. (Gracias ylmg internauta)

2. Un pequeño problema que puede paralizar todo el sistema

En el diseño de sistemas de bases de datos, las operaciones de transacción se utilizan a menudo para garantizar la integridad de los datos. Sin embargo, un diseño inadecuado puede tener fácilmente un impacto relativamente grande. El siguiente ejemplo ilustra que, aunque la integridad de los datos está garantizada, el sistema puede dejar de funcionar por completo.

==================================================== =================================================

AdoConnection1.BeginTrans;

intentar

...

if application.MessageBox('¿Está seguro de eliminar?', 'Pregunta', MB_YESNO+MB_ICONQUESTION)<>IDSí, entonces //(1)

comenzar

...

fin;

Application.MessageBox('Operación fallida', 'Advertencia', MB_OK); //(2)

AdoConnection1.CommitTrans;

excepto

Application.MessageBox('Operación fallida', 'Advertencia', MB_OK); //(3)

AdoConnection1.RollbackTrans;

fin;

==================================================== =================================================

Análisis: todos los problemas en el código anterior son causados ​​por Application.MessageBox en (1), (2) y (3), pero no es el Application.MessageBox en sí el que causa el problema, sino que bloquea el programa y requiere intervención del usuario y luego continuar realizando operaciones posteriores, si el usuario abandona la computadora en este momento o no confirma el funcionamiento de estos cuadros de diálogo, es posible que todo el sistema esté en estado de espera porque esta transacción no se ha realizado. terminó.

Para evitar este problema, existen dos principios:

(1) Una vez iniciada la transacción, el programa puede finalizarla automáticamente sin la intervención del usuario;

(2) Realizar la operación más corta de la transacción.

3. intentar... excepto... estructura final

El siguiente es un ejemplo para ilustrar la estructura try, o un ejemplo del uso de operaciones de transacción:

El código en cuestión:

==================================================== =================================================

intentar

...

AdoConnection1.BeginTrans;

...

AdoConnection1.CommitTrans;

excepto

AdoConnection1.RollbackTrans;

fin;

==================================================== =================================================

Análisis: si se produce una excepción en el código AdoConnection1.BeginTrans después del intento, saltará a AdoConnection1.RollbackTrans para su ejecución, pero AdoConnection1 no inició la transacción debido a un error, por lo que se produjo un error durante la ejecución de AdoConnection1.RollbackTrans.

Código correcto: ================================================ = ==================================================

AdoConnection1.BeginTrans;

intentar

...

...

AdoConnection1.CommitTrans;

excepto

AdoConnection1.RollbackTrans;

fin;

==================================================== =================================================

En resumen, la estructura de try se utiliza para proteger operaciones anormales. Si ocurre una excepción entre try...except, se ejecutará la operación entre except...end. Al diseñar el comando try, se debe prestar atención a la racionalidad. de la arquitectura.

4. Defraudado de la protección de sus propios asuntos

Al crear software de aplicación de base de datos, a menudo nos encontramos con los siguientes problemas: juzgar los datos originales y luego realizar las modificaciones correspondientes. Este problema parece relativamente simple, pero si consideras que hay otras personas en la red usando el mismo sistema, entonces debes considerar la posibilidad de cambios accidentales. Mi colega fue descuidado. Aunque consideró el problema multiusuario después de que se lo pedí, aún así escribió el código problemático:

==================================================== =================================================

var

adsTemp: TAdoDataSet;

está bien: booleano;

comenzar

adsTemp := TAdoDataSet.Create(self);

intentar

adsTemp.Connection := AdoConnection1;

adsTemp.CommandText := 'seleccione fid, fnumber de tb1 donde fid=120';

adsTemp.Open;

está bien := adsTemp.FieldByName('fnumber').AsInteger>100;

finalmente

adsTemp.Gratis;

fin;

si no está bien entonces

Salida;

AdoConnection1.BeginTrans;

intentar

AdoConnection1.Execute('actualizar tb1 set ffull=ffull + 1 de tb1 donde fid=120';

...

...

AdoConnection1.CommitTrans;

excepto

AdoConnection1.RollbackTrans;

fin;

fin;

==================================================== =================================================

Análisis: No sé si ha visto el problema. Los datos se juzgan antes de AdoConnection1.BeginTrans, y luego se usa AdoConnection1.Execute para cambiar los datos. Si los datos se comparten, durante el período posterior al juicio. AdoConnection1.BeginTrans, tb1 Es posible que los datos hayan cambiado y esta protección de transacciones no sirve de nada.

El método correcto es que el juicio y la modificación deben ser los mismos datos. Los siguientes son dos ejemplos de métodos (la diferencia es que la ubicación donde se inicia la transacción es diferente):

Código 1 (después de usar la protección de transacciones, los mismos datos se juzgan y modifican):

==================================================== =================================================

var

adsTemp: TAdoDataSet;

está bien: booleano;

comenzar

AdoConnection1.BeginTrans;

intentar

adsTemp := TAdoDataSet.Create(self);

intentar

adsTemp.Connection := AdoConnection1;

adsTemp.CommandText := 'seleccione fid, fnumber, ffull de tb1 donde fid=120';

adsTemp.Open;

si adsTemp.FieldByName('fnumber').AsInteger>100 entonces

comenzar

adsTemp.Editar;

adsTemp.FieldByName('ffull').AsInteger := adsTemp.FieldByName('ffull').AsInteger + 1;

anunciosTemp.Post;

fin;

finalmente

adsTemp.Gratis;

fin;

AdoConnection1.CommitTrans;

excepto

AdoConnection1.RollbackTrans;

fin;

fin;

==================================================== =================================================

Código 2 (usando la captura de excepciones, si el juicio y la modificación no son los mismos datos, se producirá una excepción durante adsTemp.Post. Esta es una característica del objeto ADODataSet):

==================================================== =================================================

var

adsTemp: TAdoDataSet;

está bien: booleano;

comenzar

adsTemp := TAdoDataSet.Create(self);

intentar

adsTemp.Connection := AdoConnection1;

adsTemp.CommandText := 'seleccione fid, fnumber, ffull de tb1 donde fid=120';

adsTemp.Open;

si adsTemp.FieldByName('fnumber').AsInteger>100 entonces

comenzar

AdoConnection1.BeginTrans;

intentar

adsTemp.Editar;

adsTemp.FieldByName('ffull').AsInteger := adsTemp.FieldByName('ffull').AsInteger + 1;

anunciosTemp.Post;

AdoConnection1.CommitTrans;

excepto

AdoConnection1.RollbackTrans;

fin;

fin;

finalmente

adsTemp.Gratis;

fin;

fin;