Hi.

In meiner Main-Sub wird ein Unterprogramm nahmens "Clean" aufgerufen.
Während des abarbeitens von Clean kann es zu fehlern kommen, auf welche ich
aber nicht im unterprogramm reagieren möchte, sondern im Hauptprogramm.
Mir ist klar, das ich den Fehler im Unterprogramm mit "On Error goto x"
auffangen kann, doch wie mache ich den Raise des Fehlers im Hauptprogramm?
Ist es möglich, einen Fehler an das Hauptprogramm "weiterzuleiten"?

Danke
Kurt

Hallo Kurt,

> Ist es möglich, einen Fehler an das Hauptprogramm "weiterzuleiten"?

in den letzten Wochen gabe es einige Postings zu diesem Thema. In Kürze:

In deinem Sub als Felerbehandlungsroutine ein

err.raise number:=Err.number, Source="Clean." & err.source,
Description:=Err:Description

einbauen. Ind er Main-Sub innerhalb der dortiegen Fehlerbahndlungsroutine
den Fehler auswerten.
In err.source. Steht dann auch der Name der auslösenden Sub drin. Einfach
mal etwas experiementieren, dann wird es schnell klar wie es abläuft...

Und mal hier in der NG Googlen nach "err.raise"

Hallo Kurt,

> In meiner Main-Sub wird ein Unterprogramm nahmens "Clean" aufgerufen.
> Während des abarbeitens von Clean kann es zu fehlern kommen, auf welche ich
> aber nicht im unterprogramm reagieren möchte, sondern im Hauptprogramm.
> Mir ist klar, das ich den Fehler im Unterprogramm mit "On Error goto x"
> auffangen kann, doch wie mache ich den Raise des Fehlers im Hauptprogramm?
> Ist es möglich, einen Fehler an das Hauptprogramm "weiterzuleiten"?


Was verstehst Du unter "Unterprogramm"? Ein Klassenmodul oder eine
Prozedur/Function, die von einer anderen, "übergeordneten"
Prozedur/Function aufgerufen wird?

Hier ein Beispiel für den zweiten Fall (Prozedur ruft eine andere
Prozedur auf):

Sub MainProzedur ()

On Error Goto MPError

'untergeordnete Prozedur "Testprozedur" aufrufen

Testprozedur

MPExit:

On Error Goto 0
Exit Sub


MPError:

'Hierher springt das Programm, wenn in MainProzedur oder
'in Testprozedur ein Fehler auftritt. Err.Source kannst Du
'auch erweitern, z.B. um den Namen des Moduls und der Prozedur

MsgBox Err.Number, Err.Source & "MyApp.MainProzedur", Err.Description

'bzw. weiterer Fehlerbehandlungs-Code

Resume MPExit

End Sub


Sub Testprozedur()

On Error Goto TPError

Code
Code
Code

TPExit:

Exit Sub

TPError:

'Falls in der Testprozedur ein Fehler auftritt, springt das Programm
'hierher. Hier wird derselbe Fehler erneut aufgerufen. Beachte, daß
'hier keine Resume-Anweisung steht. Somit wird der Fehler an
'die übergeordnete Prozedur "hochgereicht".
'Err.Source kannst Du auch hier um den Namen der Prozedur erweitern.
'So siehst Du gleich, wo der Fehler aufgetreten ist.

Err.Raise Err.Number, Err.Source & "MyApp.Testprozedur",
Err.Description

End Sub

Das funktioniert auch mit weitergehenden Prozeduraufrufen
("Testprozedur" ruft ihrerseits eine Prozedur auf, die ebenfalls wieder
eine usw.).

In allen eigenen Prozeduren löst Du nur den aufgetretenen Fehler erneut
auf - wie in Testprozedur beschrieben. Ergänze Err.Source jedesmal um
Modulname und Prozedurname. In der "obersten" Prozedur - wie z.B. in
einem Click-Ereignis etc. wertest Du den Fehler mit einer gehaltvollen
Fehlerbehandlung aus. Du hast dann in Err.Source eine genaue Abfolge der
Prozeduren, die Dein Code genommen hat. Die Prozedur, in der Dein Fehler
auftrat, wird in Err.Source als erstes aufgeführt.

Viele Grüße
Michael

Hallo Kurt,

> In meiner Main-Sub wird ein Unterprogramm nahmens "Clean" aufgerufen.
> Während des abarbeitens von Clean kann es zu fehlern kommen, auf welche
ich
> aber nicht im unterprogramm reagieren möchte, sondern im Hauptprogramm.

Ich rate mal, mit "Hauptprogramm" meinst Du Deine Sub Main.
Und "Unterprogramm" ist dann irgendeine andere Sub oder Function in Deinem
Programm.

> Mir ist klar, das ich den Fehler im Unterprogramm mit "On Error goto x"
> auffangen kann,

Genauso musst Du den Fehler in Deiner Prozedur "Clean" abfangen.

Option Explicit
mModName as String = "MyModulName"
Public Sub Clean()
On Error goto Fehler
... blablabla
... blablabla
... blablabla
Exit Sub
Fehler:
With Err
.Raise .Number, mModulName & ".Clean; " & .source, _
.Description, .HelpFile, .HelpContext
End With
End Sub

> doch wie mache ich den Raise des Fehlers im Hauptprogramm?

s.obige Prozedur "Clean".
In der Fehlerbehandlungsroutine der Sub Clean wird Err.Source um den Modul-
und Prozedurnamen erweitert und dann der Fehler per Err.Raise erneut
ausgelöst. Die Prozedur, welche Clean aufgerufen hat, erhält so den Fehler
nach oben durchgereicht. Wobei in Err.Source durch die Erweiterung auch zu
erkennen ist, wo der Fehler ursprünglich ausgelöst worden ist.

> Ist es möglich, einen Fehler an das Hauptprogramm "weiterzuleiten"?

Ja.
Nachdem Deine Sub Main die Sub Clean aufgerufen hat, wird sie bei einem
Fehler in Clean diesen Fehler durchgereicht bekommen und kann ihn
entsprechend behandeln:

Private Sub Main()
On Error Goto Fehler
....blablabla
Call Clean
...blablabla
Ausgang:
On Error Goto 0
Exit Sub
Fehler:
With Err
msgbox "Fehler: " & .Number & vbcrlf & _
"Source: " & .Source & vbcrlf & _
.Description
End With
End Sub


Dieses "Durchreichen" von Fehlern kann auch über mehrere Prozeduren
(Sub/Function) gehen. Jede durchlaufene Prozedur erweitert dabei Err.Source
um den eigenen Modul- und Prozedurnamen und macht es so möglich, den
Programmverlauf von der auslösenden Prozedur bis zum eigentlichen Fehlerort
zu sehen.

Das Prinzip ist ganz einfach. Prozeduren, die von anderen Prozeduren
aufgerufen werden, reichen den Fehler an die aufrufende Prozedur weiter.
Prozeduren der obersten Ebene, z.B. Command_Click erkennen den Fehler (wie
oben im Beispiel Sub Main) und geben entweder eine Fehlermeldung aus, oder
besser, rufen einen zentralen Errorhandler auf, der neben der Ausgabe von
Fehlermeldungen auch noch z.B. Einträge in eine Logdatei macht, E-Mails mit
Fehlerinformationen aufbereitet oder versendet usw.

Gruß aus St.Georgen
Peter Götz
www.gssg.de (mit VB-Tips u. Beispielprogrammen)