Globales Fehlerhandling

13/01/2010 - 20:05 von Claudia Maier | Report spam
Hallo,

kann mir jemand auf die Sprünge helfen.
Ich hoffe es ist einigermaßen verstàndlich.

Ziel:
Ist einfach alle nicht lokalen abgefangenen Ausnahmen, global
abzufangen.
Ist ja ein feine gute Sache.
Dann kann man mal ohne beginnen und von Zeit zu Zeit nachbessern.
Ich finde das ein toller Ansatz, wußte ich bis dato nicht.

Grundlage war für mich.
http://msdn.microsoft.com/de-de/lib...ption.aspx

http://msdn.microsoft.com/de-de/cc405402.aspx

Probleme:
a) Ich komme aber in die globale Exception rein und das immer wieder.
b) Wie und wo gebe ich das selbststàndig frei?
ThreadExceptionMy -= ?!?
Hinweis von Microsoft.

c) wie wird das gehandelt.
Zusammenhang durch ######## ersichtlich

d) EventLog, Trace Unterschied?
Wann nimmt man was am besten?
Kann man das so sagen?
Trace schreibt in eine Datei
EventLog nicht?

frmTest.cs
public partial class frmTest : Form
{
public frmTest()
{
// dient zum Testen!!!
int f = 0;
double erg = 44 / f; ########
Exception "Es wurde versucht, durch 0 (null) zu teilen."
######## ruft nun das untere auf, aber immer wieder!

Grüße

http://msdn.microsoft.com/de-de/lib...ption.aspx
Da es sich um ein statisches Ereignis handelt, müssen Sie beim
Freigeben der Anwendung die Anbindung der Ereignishandler trennen.
Andernfalls treten Speicherverluste auf.

Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

using System.Security;
using System.Security.Permissions;



namespace Rommel.Communication.TestApplication
{
static class Program
{
//public static event
System.Threading.ThreadExceptionEventHandler ThreadExceptionMy;

/// <summary>
/// The main entry point for the application.
/// </summary>
[SecurityPermission(SecurityAction.Demand, Flags SecurityPermissionFlag.ControlAppDomain)]
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);

Application.ThreadException += new
System.Threading.ThreadExceptionEventHandler
(frmTest.Application_ThreadException);
//ThreadExceptionMy += new
System.Threading.ThreadExceptionEventHandler
(frmTest.Application_ThreadException);


// Set the unhandled exception mode to force all Windows
Forms errors to go through
// our handler.
Application.SetUnhandledExceptionMode
(UnhandledExceptionMode.CatchException);
// Add the event handler for handling non-UI thread
exceptions to the event.
AppDomain.CurrentDomain.UnhandledException + new UnhandledExceptionEventHandler
(frmTest.Application_UnhandleThreadException);
Application.Run(new frmTest());
}
}
}


public partial class frmTest : Form
{
// Creates the error message and displays it.
private static DialogResult ShowThreadExceptionDialog(string
title, Exception e)
{
string errorMsg = "An application error occurred. Please
contact the adminstrator " +
"with the following information:";
errorMsg = errorMsg + e.Message + "Stack Trace:" +
e.StackTrace;
return MessageBox.Show(errorMsg, title,
MessageBoxButtons.AbortRetryIgnore,
MessageBoxIcon.Stop);
}

public static void Application_ThreadException(object sender,
ThreadExceptionEventArgs t)
{
DialogResult result = DialogResult.Cancel;
try
{
result = ShowThreadExceptionDialog("Windows Forms
Error", t.Exception);
}
catch
{
try
{
MessageBox.Show("Fatal Windows Forms Error",
"Fatal Windows Forms Error",
MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Stop);
}
finally
{
Application.Exit();
}
}

// Exits the program when the user clicks Abort.
if (result == DialogResult.Abort)
Application.Exit();
}

public static void Application_UnhandleThreadException(object
sender, UnhandledExceptionEventArgs e)
{
try
{
########
Exception ex = (Exception)e.ExceptionObject;
string errorMsg = "An application error occurred.
Please contact the adminstrator " +
"with the following information:";

// Since we can't prevent the app from terminating,
log this to the event log.
if (!EventLog.SourceExists("ThreadException"))
{
EventLog.CreateEventSource("ThreadException",
"Application");
}

// Create an EventLog instance and assign its source.
EventLog myLog = new EventLog();
myLog.Source = "ThreadException";
myLog.WriteEntry(errorMsg + ex.Message + "Stack
Trace:" + ex.StackTrace);
########
######## EventLog ist das eine Datei, ich gebe ja nirgends eine
Dateinamen an.
######## eine weitere Variante, àhnlich dem
System.Diagnostics.Trace.WriteLine("Error in Send ",
"Error");

}
catch (Exception exc)
{
try
{
MessageBox.Show("Fatal Non-UI Error",
"Fatal Non-UI Error. Could not write the error
to the event log. Reason: "
+ exc.Message, MessageBoxButtons.OK,
MessageBoxIcon.Stop);
}
finally
{
Application.Exit();
}
}
}
 

Lesen sie die antworten

#1 Konrad Neitzel
13/01/2010 - 22:14 | Warnen spam
Hallo Claudia,

ich selbst muss erst einmal sagen, dasss ich mich mit diesem globalen
Abfangen von Exceptions bisher nicht beschàftigt habe.

Zu
Ist ja ein feine gute Sache.
Dann kann man mal ohne beginnen und von Zeit zu Zeit nachbessern.
Ich finde das ein toller Ansatz, wußte ich bis dato nicht.


muss ich aber gleich Stellung beziehen: Das ist aus meiner Sicht der
komplett falsche Ansatz. Wenn Du etwas machst, dann mach es doch gleich
richtig, Und behandel die Exceptions da, wo es logisch auch hinkommt.
Dies ist garnicht einmal so kompliziert.


d) EventLog, Trace Unterschied?
Wann nimmt man was am besten?
Kann man das so sagen?
Trace schreibt in eine Datei
EventLog nicht?


Also EventLog landet im EventLog von Windows. Und Trace ist erst einmal
eine Trace Meldung und dient zum schreiben von Trace-Mitteilungen
(Ähnlich Debug Mitteilungen).
Wo Trace wie landet wird im .config der Applikation angeben. Dies kann
eine Datei sein, aber generell kann man beliebige TraceListener
schreiben.

Dies hat den großen Vorteil, dass man bei der Entwicklung nicht
entscheiden muss, wo eine Meldung landen soll. Das kann spàter immer
noch der Administrator oder User bestimmen.

Eventlog ist halt der Platz für Meldungen an die Administratoren. In
großen Unternehmen kann es sehr wünschenswert sein, wenn
Server-Applikationen Fehler im Eventlog melden. Da greifen dann halt die
ganzen Überwachungstools, die von Firmen so eingesetzt werden und
niemand muss reelmàßig in eine Datei schauen, ob Fehler aufgetreten
sind.

Das ist, was ich beitragen konnte. Vielleicht konnte ich ja etwas helfen
...

Mit den besten Grüßen,

Konrad

Ähnliche fragen