Verarbeiten synchroner Fehler in Anwendungen -- Flash CS3

Die häufigste Fehlerverarbeitung besteht aus Programmlogik für synchrone Fehler. Dabei fügen Sie im Code Anweisungen ein, um synchrone Fehler zur Laufzeit abzufangen. Mit dieser Art der Fehlerverarbeitung kann die Anwendung beim Fehlschlagen von Funktionen Laufzeitfehler feststellen und die Abarbeitung fortsetzen. Zur Programmlogik für das Abfangen von synchronen Fehlern gehören try..catch..finally-Anweisungen, mit denen Vorgänge probeweise ausgeführt, eventuelle Fehlerreaktionen von Flash Player abgefangen und schließlich bei Bedarf andere Vorgänge durchgeführt werden, um einen fehlgeschlagenen Vorgang zu verarbeiten.

Unterthemen

Verwenden von try..catch..finally-Anweisungen

Verwenden Sie für synchrone Laufzeitfehler try..catch..finally-Anweisungen, um Fehler abzufangen. Bei einem Laufzeitfehler gibt Flash Player einen Ausnahmefehler aus. Dies bedeutet, dass Flash Player die normale Ausführung unterbricht und ein spezielles Objekt vom Typ Error erstellt. Das Error-Objekt wird dann an den ersten verfügbaren catch-Block übergeben.

Die try-Anweisung umschließt Anweisungen, die möglicherweise Fehler verursachen können. Die catch-Anweisung wird stets mit einer try-Anweisung verwendet. Wenn in einer der Anweisungen des try-Anweisungsblocks ein Fehler auftritt, werden die catch-Anweisungen ausgeführt, die dieser try-Anweisung zugeordnet sind.

Die finally-Anweisung umschließt Anweisungen, die unabhängig davon ausgeführt werden, ob im try-Block ein Fehler aufgetreten ist. Wenn kein Fehler auftritt, werden nach Abschluss der Anweisungen im try-Block die Anweisungen innerhalb des finally-Blocks ausgeführt. Beim Auftreten eines Fehlers werden zuerst die entsprechende catch-Anweisung und dann die Anweisungen im finally-Block ausgeführt.

Der nachstehende Code veranschaulicht die Syntax für die Verwendung von try..catch..finally-Anweisungen:

try
{
   // Programmcode, der einen Fehler hervorrufen kann
}
catch (err:Error)
{
   // Programmcode zum Verarbeiten des Fehlers
}
finally
{
   // Programmcode, der unabhängig davon ausgeführt wird, ob ein Fehler ausgelöst wurde. Dieser Code kann
    // abschließende Bereinigung durchführen oder Maßnahmen zum Fortsetzen der Anwendung ergreifen.
}

Jede catch-Anweisung kann einen bestimmten Ausnahmetyp verarbeiten, der entsprechend angegeben ist. In catch-Anweisungen können nur Fehlerklassen angegeben werden, die Unterklassen der Error-Klasse sind. Jede catch-Anweisung wird in der angegebenen Reihenfolge überprüft. Es wird nur die erste catch-Anweisung ausgeführt, die mit dem Typ des ausgelösten Fehlers übereinstimmt. Wenn Sie die übergeordnete Error-Klasse vor einer Unterklasse der Error-Klasse testen, wird daher nur eine Übereinstimmung mit der übergeordneten Error-Klasse erkannt. Dies wird mit dem folgenden Code veranschaulicht:

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

Um ArgumentError korrekt abzufangen, müssen Sie sicherstellen, dass die spezifischeren Fehlertypen zuerst und die allgemeineren Fehlertypen später aufgeführt sind, wie im folgenden Code dargestellt ist:

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

Verschiedene Methoden und Eigenschaften der Flash Player-API lösen Laufzeitfehler aus, wenn bei der Ausführung Fehler auftreten. Beispielsweise löst die close()-Methode der Sound-Klasse einen IOError aus, wenn der Audio-Stream mit der Methode nicht geschlossen werden kann, wie im folgenden Code dargestellt ist:

var mySound:Sound = new Sound();
try
{
    mySound.close();
}
catch (error:IOError)
{
    // Fehler #2029: Kein Stream für dieses URLStream-Objekt geöffnet.
}

Sobald Sie sich mit dem Komponenten-Referenzhandbuch für ActionScript 3.0 vertraut gemacht haben, wissen Sie, welche Methoden Ausnahmen auslösen. Diese Informationen finden Sie in den Beschreibungen der einzelnen Methoden.

throw-Anweisung

Flash Player löst Ausnahmen aus, wenn in der Anwendung zur Laufzeit Fehler auftreten. Zusätzlich können Sie selbst mithilfe der throw-Anweisung explizit Ausnahmen auslösen. Beim expliziten Auslösen von Fehlern wird empfohlen, Instanzen der Error-Klasse oder einer ihrer Unterklassen auszulösen. Im folgenden Code wird eine throw-Anweisung veranschaulicht, die eine Instanz der Error-Klasse (MyErr) auslöst und schließlich eine Funktion (myFunction()) aufruft, um auf den ausgelösten Fehler zu reagieren:

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; // Fehler wegen vorzeichenloser Ganzzahlen abfangen
}
catch (error:int)
{
    throw MyError; // Fehler wegen Ganzzahlen abfangen
}
catch (error:Number)
{
    throw MyError; // Fehler wegen Zahlen abfangen
}
catch (error:*)
{
    throw MyError; // alle anderen Fehler abfangen
}
finally 
{
    myFunction(); // ggf. erforderliche Bereinigung durchführen
}

Beachten Sie, dass die catch-Anweisungen so angeordnet sind, dass die spezifischsten Datentypen zuerst aufgeführt sind. Wenn die catch-Anweisung für den Datentyp Number an erster Stelle steht, werden die catch-Anweisung für den Datentyp uint sowie die catch-Anweisung für den Datentyp int niemals ausgeführt.

Anzeigen einer einfachen Fehlermeldung

Einer der größten Vorteile des neuen Ausnahme- und Fehlerereignismodells ist, dass Sie den Benutzern mitteilen können, dass und warum ein Vorgang fehlgeschlagen ist. Ihre Aufgabe besteht darin, den Code zum Anzeigen der Meldung zu programmieren und mögliche Reaktionen anzubieten.

Im folgenden Code ist eine einfache try..catch-Anweisung zum Anzeigen des Fehlers in einem Textfeld dargestellt:

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);
            }
        }
    }
}

Mit einem breiteren Spektrum von Fehlerklassen und integrierten Compilerfehlern bietet ActionScript 3.0 umfassendere Informationen als die Vorgängerversionen über die Gründe für das Fehlschlagen von Vorgängen. Dies ermöglicht es Ihnen, stabilere Anwendungen mit besserer Fehlerverarbeitung zu erstellen.

Erneutes Auslösen von Fehlern

Beim Erstellen von Anwendungen gibt es mehrere Situationen, in denen Sie einen Fehler erneut auslösen müssen, wenn dieser nicht ordnungsgemäß verarbeitet werden kann. Beispielsweise ist im folgenden Code ein verschachtelter try..catch-Block dargestellt, der einen benutzerdefinierten ApplicationError-Fehler erneut auslöst, wenn der verschachtelte catch-Block den Fehler nicht verarbeiten kann:

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

Der verschachtelte try-Block löst einen benutzerdefinierten ApplicationError-Fehler aus, der mit dem nachfolgenden catch-Block abgefangen wird. In diesem verschachtelten catch-Block wird versucht, den Fehler zu verarbeiten. Wenn dies nicht gelingt, wird das ApplicationError-Objekt an den übergeordneten try..catch-Block übergeben.