AutoHotkey Community

Moin, Moin,

wenn Du in der direkten Umgebung der auslösenden Anweisung eine Fehlerbehandlung durchführen willst, bleibt Dir für von AHK generierte Ausnahmen meiner Meinung nach nichts anderes übrig. Wenn Du - wie im Beispiel - selbst Ausnahmen generierst, sehe ich die Notwendigkeit nicht. [c]DllCall()[/c] erzeugt automatische Ausnahmen in AHK 1.1 überhaupt nur dann, wenn die Funktion in einem [c]Try[/c] Block steht.

Irgendwas.UserMethode()


class Irgendwas
{
	; === FÜR DIE BENUTZUNG AUßERHALB ===============================
	UserMethode()
	{
		handle := this.OpenHandle()
		Ret_A  := this.MethodeA(handle)
		Ret_B  := this.MethodeB(handle, Ret_A)
		this.Free(handle)
		return Ret_B
	}

	; === INTERN ====================================================
	OpenHandle()
	{
		return DllCall("ÖffneEtwas", "ptr")
	}

	MethodeA(handle)
	{
		try ; probiere
		{
			if !(ret := DllCall("TueIrgendwasA", "ptr", handle, "ptr"))
				throw Exception("TueIrgendwasA: " A_LastError, -1)
			return ret
		}
		catch exception
		{
			throw Exception
		}
		finally ; bereinige wenn fehlschlägt
		{
			if (handle)
				this.Free(handle)
		}
	}

	MethodeB(handle, irgendwasA)
	{
		try ; probiere
		{
			if !(ret := DllCall("TueIrgendwasB", "ptr", handle, "ptr", irgendwasA, "ptr"))
				throw Exception("TueIrgendwasB: " A_LastError, -1)
			return ret
		}
		catch exception
		{
			throw Exception
		}
		finally ; bereinige wenn fehlschlägt
		{
			if (handle)
				this.Free(handle)
		}
	}

	Free(handle)
	{
		DllCall("BereinigeEtwas", "ptr", handle)
	}
}

Moin,

gibt es eigtl. in AHK ein Best Practise, was das Behandlung von Ausnahmen / Fehlern in Klassen angeht? (Exception Handling)

Vorallem, wenn man DllCall's in Methoden auslagert und gerne die Fehler abfangen und trotzdem den Speicher bereinigen will.

Am besten ohne in jeder Methode ein try, catch, finally einzubauen.


Finde das halt sehr unschön, bzw aufgebläht.
[code]Irgendwas.UserMethode()


class Irgendwas
{
; === FÜR DIE BENUTZUNG AUßERHALB ===============================
UserMethode()
{
handle := this.OpenHandle()
Ret_A := this.MethodeA(handle)
Ret_B := this.MethodeB(handle, Ret_A)
this.Free(handle)
return Ret_B
}

; === INTERN ====================================================
OpenHandle()
{
return DllCall("ÖffneEtwas", "ptr")
}

MethodeA(handle)
{
try ; probiere
{
if !(ret := DllCall("TueIrgendwasA", "ptr", handle, "ptr"))
throw Exception("TueIrgendwasA: " A_LastError, -1)
return ret
}
catch exception
{
throw Exception
}
finally ; bereinige wenn fehlschlägt
{
if (handle)
this.Free(handle)
}
}

MethodeB(handle, irgendwasA)
{
try ; probiere
{
if !(ret := DllCall("TueIrgendwasB", "ptr", handle, "ptr", irgendwasA, "ptr"))
throw Exception("TueIrgendwasB: " A_LastError, -1)
return ret
}
catch exception
{
throw Exception
}
finally ; bereinige wenn fehlschlägt
{
if (handle)
this.Free(handle)
}
}

Free(handle)
{
DllCall("BereinigeEtwas", "ptr", handle)
}
}[/code]

Oder muss ich den Weg so gehen?