Verarbeiten synchroner Fehler in einer Anwendung

Wenn Sie mit synchronen Laufzeitfehlern arbeiten, verwenden Sie die try..catch..finally -Anweisungen zum Abfangen von Fehlern. Bei einem Laufzeitfehler gibt die Flash-Laufzeitumgebung einen Ausnahmefehler aus. Dies bedeutet, dass Flash Player die normale Ausführung unterbricht und ein spezielles Objekt mit dem Error-Typ 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 Anweisung im try -Anweisungsblock ein Fehler auftritt, werden die catch -Anweisungen ausgeführt, die dieser try -Anweisung zugewiesen 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 
{ 
    // some code that could throw an error 
} 
catch (err:Error) 
{ 
    // code to react to the error 
} 
finally 
{ 
    // Code that runs whether an error was thrown. This code can clean 
    // up after the error, or take steps to keep the application running. 
}

Jede catch -Anweisung kann einen bestimmten Ausnahmetyp verarbeiten. 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. Nur die erste catch -Anweisung, die mit dem Typ des ausgelösten Fehlers übereinstimmt, wird ausgeführt. Wenn Sie erst die übergeordnete Error-Klasse und dann eine 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); 
}

Der vorstehende Code führt zu folgender Ausgabe:

<Error> I am an ArgumentError

Um „ArgumentError“ korrekt abzufangen, stellen Sie sicher, dass die spezifischeren Fehlertypen zuerst und die allgemeineren Fehlertypen später aufgeführt sind, wie im folgenden Code gezeigt:

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 ActionScript-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) 
{ 
    // Error #2029: This URLStream object does not have an open stream. 
}

Wenn Sie mit dem ActionScript 3.0-Referenzhandbuch für die Adobe Flash-Plattform vertraut werden, merken Sie, welche Methoden Ausnahmen auslösen, wie in den Beschreibungen der einzelnen Methoden erläutert.

Die Flash-Laufzeitumgebungen lösen Ausnahmen aus, wenn in Ihrer ausgeführten Anwendung Probleme 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; // Catch unsigned integer errors. 
} 
catch (error:int) 
{ 
    throw MyError; // Catch integer errors. 
} 
catch (error:Number) 
{ 
    throw MyError; // Catch number errors. 
} 
catch (error:*) 
{ 
    throw MyError; // Catch any other error. 
} 
finally  
{ 
    myFunction(); // Perform any necessary cleanup here. 
}

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

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.

Der folgende Code zeigt eine einfache try..catch -Anweisung zum Anzeigen des Fehlers in einem Textfeld:

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 von ActionScript über die Gründe für das Fehlschlagen von Vorgängen. Diese Informationen ermöglichen es Ihnen, stabilere Anwendungen mit besserer Fehlerverarbeitung zu erstellen.

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. Der folgende Code zeigt z. B. einen verschachtelten try..catch -Block, der einen benutzerdefinierten ApplicationError-Fehler auslöst, wenn der verschachtelte catch -Block den Fehler nicht verarbeiten kann:

try 
{ 
    try 
    { 
        trace("<< try >>"); 
        throw new ApplicationError("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); 
}

Mit diesem Codebeispiel wird folgende Ausgabe generiert:

<< 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.