Willkommen zum sechsten Teil der “Neu in ActionScript 3″-Reihe und diesmal möchte ich einen Einblick in die neuen Fähigkeiten des Error-Handlings geben. Dazu gehört neben der Möglichkeit Fehler(Ausnahmen/Exceptions) durch das try…catch Konstrukt abzufangen und zu verarbeiten auch das auslösen und definieren eigener Fehler. Manche werden jetzt vielleicht sagen: “Wieso eigene Fehler werfen, ich bin schon froh wenn meine Anwendung so keine Fehler mehr wirft.”, aber weshalb dies aber nur begrenzt richtig ist schauen wir uns in diesem Beitrag an.

Hingegen der landläufigen Meinung ist ein Fehler ansich erstmal nichts schlimmes… was ihn problematisch werden lassen könnte ist ihn einfach zu ignorieren, denn dies führt in der Regel zur Programmbeendung, bzw. Fehlfunktion des Programms. Um einen Fehler adäquat zu behandeln gibt es in ActionScript 3 nun den try…catch Block, welcher wie folgt funktioniert:

public function doSomething( param:* ):void
{
    var string:String = param;
}

Würden wir dieser Funktion nun einen Parameter von einem Typ != String übergeben würde die Zuweisung des Parameters param auf die Variable string einen Fehler werfen und das Programm (zumindest im Debug-Modus) angehalten.

public function doSomething( param:* ):void
{
    try
    {
        var string:String = param;
    }
    catch( error:Error )
    {
        trace( "typcasting not possible" );
    }
    finally
    {
        trace( "did what i have to do" );
    }
}

Platzieren wir diese Zuweisung nun innerhalb eines try Blocks können wir den geworfenen Fehler mittels des catch Aufrufs abfangen und entsprechend unserer Vorstellungen drauf reagieren. Es können auch mehrere catch-Blöcke hintereinander definiert werden um auf verschiedene Fehler zu reagieren (TypeError u.ä.). Am Ende gibt es noch einen finally-Block. Dieser Code wird unabhängig von dem try…catch-Ergebnis immer ausgeführt.

Richtig interessant wird das ganze vor allem im Zusammenhang mit der Möglichkeit eigene Fehler zu definieren und bei Bedarf zu werfen. Einen bereits vom ActionScript-Core definierte Fehler werfen wir wie folgt:

throw new Error( "my message to the world" );

Um einen eigenen Fehler zu deklarieren erstellen wir einfach eine neue Klasse und lassen die vor ursprünglichen Fehler-Klasse erben:

public class MyError extends Error
{
    public function MyError( message:String='', id:int=0 ):void
    {
        super( message, id );
    }
}

Und fertig ist unsere eigene Fehlerklasse, welche wir nun bequem mittels folgendem Aufruf verwenden können:

throw new MyError( "my first own error" );

Wieso nun das Ganze? Das ist eigentlich eine grundsätzliche Frage der Programmierung und hat wenig mit ActionScript 3 selbst zu tun, aber ich gehe trotzdem kurz darauf ein:
In großen Projekten und vor allem beim Einsatz von Frameworks und Bibliotheken arbeitet man oft mit fremden Code und muss sich mehr oder weniger darauf verlassen das dieser tut was man von ihm erwartet. Verwende ich nun z.B. als Entwickler eine externe Bibliothek und rufe eine Funktion von dieser auf, dann verlasse ich mich darauf, dass das was diese Funktion zurückliefert auch korrekt ist. Sollte dies aber aus irgendeinem Grund nicht der Fall sein und ich bemerke dies nicht arbeite ich ggf. mit falschen Werten weiter, wirft die Bibliothek nun aber einen entsprechenden Fehler kann ich passend darauf reagieren und entscheiden wie ich weiter innerhalb der Anwendung verfahre, so kann die Stabilität der Anwendung gewährleistet werden.
Dies ist nur ein möglicher Anwendungsfall, aber ich hoffe das er geholfen hat den Sinn und Zweck von Errorhandling ein wenig zu verdeutlichen.

Andere Beiträge der Reihe:

• Neu in ActionScript 3: Grundlagen
• Neu in ActionScript 3: Sealed Classes
• Neu in ActionScript 3: Namespaces
• Neu in ActionScript 3: Reguläre Ausdrücke
• Neu in ActionScript 3: Typsicherheit zur Laufzeit
• Neu in ActionScript 3: Die neuen Datentypen