Fehlerbehandlung (Teil 1)

Bei komplexen Algorithmen oder langen, sich wiederholenden Anweisungsfolgen ist es für den Entwickler oft schwierig, eine übersichtliche und zentrale Fehlerbehandlung zu implementieren.

Eine Methode der Fehlerbehandlung besteht darin, nach jeder Anweisung deren Resultat abzufragen und zu verarbeiten. Daraus ergeben sich aber meistens sehr stark verschachtelte oder verkettete Konstrukte aus Fehlerabfragen und -behandlungen.

Neben dieser klassischen Methode möchte ich Ihnen in diesem Artikel eine elegante Alternative dazu vorstellen, mit der Sie die Fehlerbehandlung erheblich vereinfachen können: Ausnahmebehandlung mit dem try-Block.

Bei einer einfachen Methode der Fehlerbehandlung wird nach jeder Anweisung deren Resultat geprüft, etwa so:

tErr # Anw1();
if (tErr = _ErrOK)
{
  tErr # Anw2();
  if (tErr = _ErrOK)
  {
    tErr # Anw3();
  }
}

if (tErr != _ErrOK)
{
  // Fehlerbehandlung
}

Bei dieser Vorgehensweise leidet die Übersichtlichkeit und Lesbarkeit des Quelltextes, weil die Verschachtelung mit jeder Anweisung steigt. Eine andere Variante dieser Fehlerbehandlung sieht so aus:

tErr # Anw1();
if (tErr = _ErrOK)
  tErr # Anw2();
if (tErr = _ErrOK)
  tErr # Anw3();

if (tErr != _ErrOK)
{
  // Fehlerbehandlung
}

Dabei stehen die einzelnen Anweisungen in der gleichen Ebene, allerdings wird auch im Fehlerfall für jede Anweisung eine Überprüfung des Resultats durchgeführt.

try and error

Der try-Block kann die Fehlerbehandlung erheblich vereinfachen. Er kapselt mehrere Anweisungen und ermöglicht die getrennte Verarbeitung von Fehlern, die innerhalb dieser Anweisungen auftreten. Ein Fehler stellt hierbei eine Ausnahme (engl. exception) in der Programmlogik da, die separat von dieser zu behandeln ist. Die Ausnahmebehandlung sieht wie folgt aus:

try
{
  Anw1();
  Anw2();
  Anw3();
}

tErr # ErrGet();

if (tErr != _ErrOK)
{
  // Fehlerbehandlung
}

Setzt eine der Anweisungen den globalen Fehlerwert, wird der try-Block nach der Anweisung automatisch verlassen und die Prozedur nach dem Block fortgesetzt. Dort kann der aufgetretene Fehler mit der Funktion ErrGet() abgefragt und verarbeitet werden.
Die meisten nativen CONZEPT 16-Funktionen setzen diesen Fehlerwert automatisch. Bei eigenen Funktionen kann der Fehlerwert mit der Funktion ErrSet() gesetzt werden:

sub Anw
()
: int;

  local
  {
    tErr : int;
  }

{
  if (…)
    tErr # _ErrUnavailable;

  ErrSet(tErr);

  return(tErr);
}

Reicht der Fehlerwert zur eindeutigen Bestimmung des Fehlers nicht aus, können die Anweisungen innerhalb des try-Blockes mit Labels unterteilt werden:

try
{
  :Anw1
  Anw1();
  :Anw2
  Anw2();
  :Anw3
  Anw3();
}

tErr # ErrGet();

if (tErr != _ErrOK)
{
  switch (ErrPos())
  {
    case :Anw1 : …
    case :Anw2 : …
    case :Anw3 : …
  }
}

Bei der Fehlerbehandlung kann dann die Fehlerposition mit der Funktion ErrPos() abgefragt und verarbeitet werden.

Das ist die grundlegende Funktionsweise der Behandlung von Ausnahmen mit try-Blöcken in CONZEPT 16. In folgenden Artikeln werden wir auf Sonderfälle bei der Ausnahmebehandlung eingehen und weitere Funktionen zum Umgang mit Fehlern erläutern.