Feedback

VB - Extended ExceptionHandling Klasse

Veröffentlicht von am 13.07.2009
(1 Bewertungen)
Zum Behandeln von Exceptions.

Die Klasse kann Logdateien (auf Wunsch mit Rotation) und in die Windows-Ereignisanzeige schreiben. Wahlweise werden Popupfenster gezeigt oder die Klasse kann komplett deaktiviert werden. Interne Fehler (z.B. bei Zuweisung eines falschen Logdatei-Namens) lösen ein OnError Event aus.

Kommentare und Kritiken sind willkommen.

Beispielanwendung:
        Dim err As New ExtendedExceptionHandling("C:\Testlogfile.log", ExtendedExceptionHandling.RotationType.Daily, True, True)
err.HandleException(New Exception("blahblah"), "Informationen")

err.RaisePopupOnException = False
err.HandleException(New AccessViolationException("zugriffsverletzung"))

err.LogToFile = False
err.HandleException(New Exception("Diese exc darf nicht in der Datei stehen"))

err.WriteToWindowsEventLog = False
err.HandleException(New Exception("Diese ex wird völlig ignoriert"))

err.RaisePopupOnException = True
err.HandleException(New Exception("Diese ex wird nur als fenster angezeigt"))

err.LogToFile = True
err.HandleException(New Exception("wieder in datei"))
err.RaisePopupOnException = False
err.LogfileRotation = ExtendedExceptionHandling.RotationType.Daily
err.HandleException(New Exception("Daily Rotation"))

err.LogfileRotation = ExtendedExceptionHandling.RotationType.Weekly
err.HandleException(New Exception("Weekly Rotation"))

err.Disabled = True
err.HandleException(New Exception("Hilfe!"))
GFU-Schulungen  [Anzeige]

VB.NET 2017/2015/2013 Aufbau

Nach dieser Schulung können Sie mittels objektorientierter Modelle in VB.NET 2017/2015/2013 wiederverwendbare Elemente eigenständig erstellen.

ASP.NET Core und Angular Komplett für .NET-Entwickler

Sie  lernen in drei (3) Tagen wie man mit  ASP.NET Core und den Technologien  MVC, Entity Framework, WebAPI und  Razor professionelle sowie moderne  Web-Anwendungsarchitekturen aufbaut.  Die Schulung ist der perfekte  Einstieg um insbesondere datengetriebene  und präsentationsorientierte  Applikationen auf Basis der robusten und  skalierbaren ASP.NET Core  Plattform zu erstellen. Nach der Veranstaltung kennen Sie die Konzepte von Angular und können Angular in neue und bestehende ASP.NET-Anwendungen einsetzen.

Namespace Base.ExceptionHandling

    ''' <summary>
    ''' Behandelt Ausnahmefehler, das Event OnError wird ausgelöst wenn bei der Fehlerbehandlung etwas schief läuft
    ''' </summary>
    ''' <remarks>Fehlerbehandlungsklasse Revision 0</remarks>
    Public Class ExtendedExceptionHandling
        Public Enum RotationType
            None = 0
            Daily = 1
            Weekly = 2
            Monthly = 3
            Yearly = 4
        End Enum

        Private _ex As Exception
        Private _Logfile As String = ""
        Private _LogToFile As Boolean
        Private _RaisePopup As Boolean
        Private _Disabled As Boolean = False
        Private _LogfileRotation As RotationType
        Private _InternalLogfilename As String = ""

        Private _WriteToWindowsEventLog As Boolean = False
        Private _EventlogAppName As String = "ApplicationName"
        Private _EventlogLogName As String = "ApplicationGroupName"

        Public Event OnError(ByVal Message As String)

        ''' <summary>
        ''' Name der Anwendung der in der Windows-Ereignisanzeige angezeigt wird
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property EventlogApplicationName() As String
            Get
                Return _EventlogAppName
            End Get
            Set(ByVal value As String)
                _EventlogAppName = value
            End Set
        End Property

        ''' <summary>
        ''' Name der Ereignisanzeigen-Gruppe (z.B. "Anwendung", "Sicherheit" usw)
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property EventlogLogfileGroupName() As String
            Get
                Return _EventlogLogName
            End Get
            Set(ByVal value As String)
                _EventlogLogName = value
            End Set
        End Property

        ''' <summary>
        ''' Aktiviert/Deaktiviert das Schreiben in die Windows-Ereignisanzeige
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks>Mit EventlogApplicationName und EventlogLogfileGroupName kann das Ziel angegeben werden</remarks>
        Public Property WriteToWindowsEventLog() As Boolean
            Get
                Return _WriteToWindowsEventLog
            End Get
            Set(ByVal value As Boolean)
                _WriteToWindowsEventLog = value
            End Set
        End Property

        ''' <summary>
        ''' Absoluter Pfad zur Logdatei
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property LogfilePath() As String
            Get
                Return _Logfile
            End Get
            Set(ByVal value As String)
                _Logfile = value
                SetNewLogfileName()
            End Set
        End Property

        ''' <summary>
        ''' Schaltet das Logging in eine Datei
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property LogToFile() As Boolean
            Get
                Return _LogToFile
            End Get
            Set(ByVal value As Boolean)
                If _Logfile <> "" Or value = False Then
                    _LogToFile = value
                Else
                    RaiseEvent OnError("Die Logdatei muss angegeben sein bevor der das Logging in eine Datei angeschaltet wird.")
                End If
            End Set
        End Property

        ''' <summary>
        ''' Schaltet ob IMMER ein Fehlerfenster angezeigt werden soll
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property RaisePopupOnException() As Boolean
            Get
                Return RaisePopupOnException
            End Get
            Set(ByVal value As Boolean)
                _RaisePopup = value
            End Set
        End Property

        ''' <summary>
        ''' Schaltet die Fehlerbehandlung über diese Klasse an/aus
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property Disabled() As Boolean
            Get
                Return _Disabled
            End Get
            Set(ByVal value As Boolean)
                _Disabled = value
            End Set
        End Property

        ''' <summary>
        ''' Schaltet die Fehlerbehandlung über diese Klasse an/aus
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property Enabled() As Boolean
            Get
                Return Not (_Disabled)
            End Get
            Set(ByVal value As Boolean)
                _Disabled = Not (value)
            End Set
        End Property

        ''' <summary>
        ''' Gibt an in welchem Intervall eine neue Logdatei erzeugt wird
        ''' </summary>
        ''' <value></value>
        ''' <returns></returns>
        ''' <remarks></remarks>
        Public Property LogfileRotation() As RotationType
            Get
                Return _LogfileRotation
            End Get
            Set(ByVal value As RotationType)
                _LogfileRotation = value
                SetNewLogfileName()
            End Set
        End Property

        ''' <summary>
        ''' Setzt den neuen Namen für tägliche/wöchentliche/monatliche Logfiles
        ''' </summary>
        ''' <remarks></remarks>
        Private Sub SetNewLogfileName()
            _InternalLogfilename = _Logfile
            Dim FileNameParts() As String = _Logfile.Split(".")
            If FileNameParts.Length < 2 Then
                RaiseEvent OnError("Der Logfile-Dateiname muss mit Erweiterung (z.B. 'log.txt') angegeben werden, wenn tägliche Logfiles erzeugt werden sollen.")
                Exit Sub
            End If

            Dim FileNameExtension As String = FileNameParts(FileNameParts.Length - 1)
            Dim LogRot As String = ""
            Select Case _LogfileRotation
                Case RotationType.Daily : LogRot = " " & DateAndTime.Now.Year & "-" & DateAndTime.Now.Month & "-" & DateAndTime.Now.Day
                Case RotationType.Weekly : LogRot = " " & DateAndTime.Now.Year & "-W" & DatePart(DateInterval.WeekOfYear, Date.Now)
                Case RotationType.Monthly : LogRot = " " & DateAndTime.Now.Year & "-M" & DateAndTime.Now.Month
                Case RotationType.Yearly : LogRot = " " & DateAndTime.Now.Year
            End Select

            _InternalLogfilename = Left(_Logfile, Len(_Logfile) - Len(FileNameExtension) - 1) & _
                        LogRot & "." & FileNameExtension

        End Sub

        ''' <summary>
        ''' Konstruktor
        ''' </summary>
        ''' <remarks>Defaults: DebugMode = false, LogToFile = false, LogfileRotation = none, RaisePopup = true</remarks>
        Public Sub New()
            _Logfile = ""
            _LogfileRotation = RotationType.None
            _LogToFile = False
            _RaisePopup = True
        End Sub

        ''' <summary>
        ''' Konstruktor
        ''' </summary>
        ''' <param name="LogfilePath"></param>
        ''' <param name="LogfileRotation"></param>
        ''' <param name="RaisePopup"></param>
        ''' <remarks></remarks>
        Public Sub New(ByVal LogfilePath As String, Optional ByVal LogfileRotation As RotationType = RotationType.Weekly, Optional ByVal RaisePopup As Boolean = True, Optional ByVal WriteToWindowsEventLog As Boolean = False)
            _Logfile = LogfilePath
            _LogToFile = True
            _LogfileRotation = LogfileRotation
            _RaisePopup = RaisePopup
            _WriteToWindowsEventLog = WriteToWindowsEventLog
            SetNewLogfileName()
        End Sub

        ''' <summary>
        ''' Behandelt einen Ausnahmefehler
        ''' </summary>
        ''' <param name="ex"></param>
        ''' <remarks>Globale Einstellung für Dateilogging und Popupfenster werden berücksichtigt</remarks>
        Public Sub HandleException(ByVal ex As Exception)
            HandleException(ex, "", _RaisePopup)
        End Sub

        ''' <summary>
        ''' Behandelt einen Ausnahmefehler
        ''' </summary>
        ''' <param name="ex"></param>
        ''' <param name="Remarks">Bemerkungen</param>
        ''' <remarks>Globale Einstellung für Dateilogging und Popupfenster werden berücksichtigt</remarks>
        Public Sub HandleException(ByVal ex As Exception, ByVal Remarks As String)
            HandleException(ex, Remarks, _RaisePopup)
        End Sub

        ''' <summary>
        ''' Behandelt einen Ausnahmefehler
        ''' </summary>
        ''' <param name="ex"></param>
        ''' <param name="RaisePopup">Popupfenster anzeigen?</param>
        ''' <remarks>Globale Einstellung für Dateilogging wird berücksichtigt</remarks>
        Public Sub HandleException(ByVal ex As Exception, ByVal RaisePopup As Boolean)
            HandleException(ex, "", RaisePopup)
        End Sub

        ''' <summary>
        ''' Behandelt einen Ausnahmefehler
        ''' </summary>
        ''' <param name="ex"></param>
        ''' <param name="Remarks">Bemerkungen</param>
        ''' <param name="RaisePopup">Popup Fenster anzeigen?</param>
        ''' <remarks>Globale Einstellung für Dateilogging wird berücksichtigt</remarks>
        Public Sub HandleException(ByVal ex As Exception, ByVal Remarks As String, ByVal RaisePopup As Boolean)

            'Fehlerbehandlung abgeschaltet?
            If _Disabled = True Then
                RaiseEvent OnError(ex.Message)
                Throw ex
                Exit Sub
            End If

            Dim InnerEx As Exception = Nothing

            Dim LogMessage As String = ""
            Dim WinMessage As String = ""

            Dim Message As String = ex.Message
            Dim ModuleName As String
            If Not ex.TargetSite Is Nothing Then
                ModuleName = ex.TargetSite.ToString
            Else
                ModuleName = "*unbekannt*"
            End If

            Dim Trace As String = ex.StackTrace

            LogMessage = vbCrLf & DateAndTime.Now & " -----------------------------------------------------" & vbCrLf
            LogMessage += "[EXCEPTION in Modul: " & ModuleName & "] "
            If Remarks <> "" Then LogMessage += "[" & Remarks & "]"
            LogMessage += vbCrLf & "[MESSAGE] " & ex.Message & vbCrLf
            LogMessage += "[STACKTRACE] " & Trace

            WinMessage = "Fehler in Modul " & ModuleName & ":" & vbCr
            WinMessage += ex.Message

            Try
                InnerEx = ex.InnerException

                'Inner Exception hinzufügen wenn möglich
                If Not InnerEx Is Nothing Then
                    LogMessage += vbCrLf & "[INNER EXCEPTION in Modul " & InnerEx.TargetSite.ToString & "] " & vbCrLf
                    LogMessage += "[INNER STACKTRACE] " & InnerEx.StackTrace

                    WinMessage += vbCr & "Innere Ausnahme in Modul " & InnerEx.TargetSite.ToString & ":" & vbCr
                    WinMessage += InnerEx.Message
                End If

                'In Datei loggen
                If _LogToFile = True Then
                    FileOpen(93, _InternalLogfilename, OpenMode.Append, OpenAccess.ReadWrite)
                    Print(93, LogMessage)
                    FileClose(93)
                End If

                'Popup Fenster anzeigen
                If RaisePopup = True Then MsgBox(WinMessage, MsgBoxStyle.Critical, "Programmfehler")

                'Windows Eventlog
                If _WriteToWindowsEventLog = True Then WriteToEventLog(LogMessage, EventLogEntryType.Error)

            Catch exp As Exception
                RaiseEvent OnError("Fehler beim Behandeln eines Ausnahmefehlers: " & exp.Message & " - " & exp.StackTrace.ToString)
            End Try
        End Sub

        ''' <summary>
        ''' Schreibt ins Windows-Log
        ''' </summary>
        ''' <param name="Entry">Nachricht</param>
        ''' <param name="EventType">Typ</param>
        ''' <remarks></remarks>
        Private Sub WriteToEventLog(ByVal Entry As String, ByVal EventType As EventLogEntryType)
            Dim objEventLog As New EventLog
            Try
                'Applikation registrieren, wenn unbekannt
                If Not EventLog.SourceExists(_EventlogAppName) Then
                    EventLog.CreateEventSource(_EventlogAppName, _EventlogLogName)
                End If
                objEventLog.Source = _EventlogAppName
                'Schreibt in das Eventlog
                objEventLog.WriteEntry(Entry, EventType)
            Catch Ex As Exception
                RaiseEvent OnError("Konnte kein Windows-Ereignis schreiben: " & Ex.Message)
            End Try
        End Sub

    End Class
End Namespace

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!