Gestión de errores sincrónicos en una aplicación -- Flash CS3

La gestión de errores más habitual hace referencia a la lógica de gestión de errores sincrónicos, en la que se insertan sentencias en el código para capturar errores sincrónicos en tiempo de ejecución. El tipo de gestión de errores permite que la aplicación observe los errores en tiempo de ejecución y se recupere cuando fallen las funciones. La lógica para capturar un error sincrónico incluye sentencias try..catch..finally, que intentan realizar una operación, capturar respuestas de errores de Flash Player y, por último, ejecutar otras operaciones para gestionar la operación que ha fallado.

Subtemas

Utilización de sentencias try..catch..finally

Cuando se gestionan errores sincrónicos en tiempo de ejecución, deben usarse las sentencias try..catch..finally para capturar errores. Si se produce un error de tiempo de ejecución, Flash Player genera una excepción, lo que significa que suspende la ejecución normal y crea un objeto especial de tipo Error. El objeto Error se genera en el primer bloque catch disponible.

La sentencia try incluye sentencias que podrían provocar errores. La sentencia catch siempre se debe utilizar con una sentencia try. Si se detecta un error en una de las sentencias del bloque try, se ejecutarán las sentencias catch asociadas a la sentencia try.

La sentencia finally incluye sentencias que se ejecutarán independientemente de que se produzcan errores en el bloque try. Si no hay errores, las sentencias del bloque finally se ejecutarán una vez que hayan finalizado las sentencias del bloque try. Si se producen errores, primero se ejecutará la sentencia catch correspondiente, seguida de las instancias del bloque finally.

El código siguiente muestra la sintaxis necesaria para usar las sentencias try..catch..finally:

try
{
   // código que podría generar un error
}
catch (err:Error)
{
   // código para reaccionar ante el error
}
finally
{
   // Código que se ejecuta independientemente de la generación de error. Este código puede realizar una limpieza
    // después del error, o bien tomar las medidas necesarias para mantener la aplicación en ejecución.
}

Cada sentencia catch identifica el tipo de excepción específico que gestiona. La sentencia catch puede especificar sólo clases de errores que son subclases de la clase Error. Cada sentencia catch se comprueba por orden. Sólo se ejecutará la primera sentencia catch que coincida con el tipo de error generado. Dicho de otra forma, si primero se comprueba la clase Error de nivel superior y luego la subclase de la clase Error, únicamente coincidirá la clase Error de nivel superior. En el código siguiente se muestra este escenario:

try
{
    throw new ArgumentError("I am an ArgumentError");
}
catch (error:Error)
{
    trace("<Error> " + error.message);
}
catch (error:ArgumentError)
{
    trace("<ArgumentError> " + error.message);
}

<Error> I am an ArgumentError

A fin de capturar correctamente la clase de error ArgumentError, es necesario asegurarse de que los tipos de error más específicos se enumeran primero, y que los más genéricos aparecen después, tal como se muestra en el código siguiente:

try
{
    throw new ArgumentError("I am an ArgumentError");
}
catch (error:ArgumentError)
{
    trace("<ArgumentError> " + error.message);
}
catch (error:Error)
{
    trace("<Error> " + error.message);
}

Varios métodos y propiedades de la API de Flash Player generan errores en tiempo de ejecución si detectan errores durante la ejecución. Por ejemplo, el método close() de la clase Sound genera un error IOError si no puede cerrar el flujo de audio, tal como se muestra en el código siguiente:

var mySound:Sound = new Sound();
try
{
    mySound.close();
}
catch (error:IOError)
{
    // Error nº 2029: Este objeto URLStream no tiene ningún flujo abierto.
}

A medida que el usuario se familiarice con la Referencia del lenguaje y componentes ActionScript 3.0, reconocerá los métodos que generan excepciones, tal como se detalla en la descripción de cada método.

La sentencia throw

Flash Player genera excepciones cuando detecta errores en la aplicación en tiempo de ejecución. Asimismo, se pueden generar excepciones explícitamente mediante la sentencia throw. Si se generan errores de forma explícita, Adobe recomienda generar instancias de la clase Error o sus subclases. En el código siguiente se muestra una sentencia throw que genera una instancia de la clase Error, MyErr, y que termina por llamar a la función myFunction() como respuesta tras la generación del error:

var MyError:Error = new Error("Encountered an error with the numUsers value", 99);
var numUsers:uint = 0;
try
{
    if (numUsers == 0)
    {
        trace("numUsers equals 0");
    }
}
catch (error:uint)
{
    throw MyError; // Capturar errores de valor entero sin signo.
}
catch (error:int)
{
    throw MyError; // Capturar errores de valor entero.
}
catch (error:Number)
{
    throw MyError; // Capturar errores de número.
}
catch (error:*)
{
    throw MyError; // Capturar cualquier error.
}
finally 
{
    myFunction(); // Realizar aquí la limpieza necesaria.
}

Debe tenerse en cuenta que las sentencias catch se ordenan de manera que los tipos de datos más específicos se muestren en primer lugar. Si la sentencia catch del tipo de datos Number se muestra primero, las sentencias catch de los tipos de datos uint e int nunca se ejecutarán.

Visualización de un mensaje de error simple

Una de las mayores ventajas del nuevo modelo de eventos de error y excepción radica en que permite indicar a los usuarios cuándo y por qué falla una acción. La parte del usuario consiste en escribir el código para que se muestre el mensaje y se ofrezcan opciones a modo de respuesta.

En el código siguiente se muestra una instrucción try..catch simple que muestra el error en un campo de texto:

package
{
    import flash.display.Sprite;
    import flash.text.TextField;
    
    public class SimpleError extends Sprite
    {
        public var employee:XML = 
            <EmpCode>
                <costCenter>1234</costCenter>
                <costCenter>1-234</costCenter>
            </EmpCode>;

        public function SimpleError()
        {
            try
            {
                if (employee.costCenter.length() != 1)
                {
                    throw new Error("Error, employee must have exactly one cost center assigned.");
                }
            } 
            catch (error:Error)
            {
                var errorMessage:TextField = new TextField();
                errorMessage.autoSize = TextFieldAutoSize.LEFT;
                errorMessage.textColor = 0xFF0000;
                errorMessage.text = error.message;
                addChild(errorMessage);
            }
        }
    }
}

Al usar una mayor gama de clases de error y errores de compilador incorporados, ActionScript 3.0 proporciona más información que las versiones anteriores acerca del motivo por el que falla algo. Esto permite crear aplicaciones más estables con una mejor gestión de errores.

Regeneración de errores

Al crear aplicaciones, pueden darse varias circunstancias en las que sea necesario volver a generar un error, si éste no consigue gestionarse adecuadamente. Por ejemplo, en el código siguiente se muestra un bloque try..catch anidado, que vuelve a generar un error ApplicationError personalizado si el bloque catch no puede gestionar el error:

try
{
    try
    {
        trace("<< try >>");
        throw new ArgumentError("some error which will be rethrown");
    }
    catch (error:ApplicationError)
    {
        trace("<< catch >> " + error);
        trace("<< throw >>");
        throw error;
    }
    catch (error:Error)
    {
        trace("<< Error >> " + error);
    }
}
catch (error:ApplicationError)
{
    trace("<< catch >> " + error);
}

<< try >>
<< catch >> ApplicationError: some error which will be rethrown
<< throw >>
<< catch >> ApplicationError: some error which will be rethrown

El bloque try anidado genera un error ApplicationError personalizado que captura el bloque catch posterior. Este bloque catch anidado puede intentar gestionar el error y, de no conseguirlo, puede generar el objeto ApplicationError en el bloque try..catch contenido.