Exceptionless

    • Allgemein
    • .NET (FX) 4.5–4.8

    Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von WhitePage.

      Exceptionless

      Jo, da ich mal wieder zu viel Zeit habe möchte ich euch in diesem Tutorial Exceptionless vorstellen und anschließend eine Möglichkeit zeigen, wie alle Fehler ohne unzählige Try-Catch-Blöcke abgefangen und zu einer Prozedur umgeleitet werden können.
      Aber zuerst ein wenig über Exceptionless.

      Was ist Exceptionless?
      Exceptionless heißt übersetzt Fehlerfrei - ein Zustand, den jeder Entwickler mit seiner Anwendung erreichen will. Das Problem dabei ist, dass die meisten Entwickler nicht genug Zeit haben, um das Programm jeden Tag mehrere Stunden zu testen und selbst wenn sie diese Zeit hätten würden sie niemals auf ein paar merkwürdigen Aktionen von den Endnutzern kommen. Das müssen sie auch gar nicht, denn die Benutzer können ja auch einfach sagen, was nicht funktioniert. Und da kommt Exceptionless ins Spiel. Mit dieser Software ist es möglich dem Benutzer möglich, dem Entwickler einen Aussagekräftigen Fehlerbericht zu senden. Somit muss der Benutzer keinen eigenen Text schreiben und der Entwickler bekommt genau das zu sehen, was ihn wirklich Interessiert.

      Exceptionless ist ein sehr ausgereiftes System, welches in Echtzeit arbeitet. Das Programm sendet den Fehler und schon werden alle Informationen übersichtlich auf der Website angezeigt.




      Fangen wir an!

      Als erstes müsst ihr euch einen Account erstellen. Das könnt ihr hier tun. Nachdem ihr das getan habt könnt ihr euer erstes Projekt hinzufügen. Nachdem das getan ist, kommt ihr auf eine Seite, auf der euch genau erklärt wird, wie ihr vorgehen müsst. Ich will das hier auch einmal Schritt für Schritt auf Deutsch beschreiben:

      1. Ihr öffnet Visual Studio in Visual Studio eure Projektmappe. Anschließend geht ihr auf Projekt > NuGet-Pakete verwalten.
      WICHTIG: Rechts, wo Installierte Pakete, Online und Aktualisierungen steht müsst ihr auf Online sein. Nun gebt ihr rechts oben "Exceptionless" ein. Als nächstes wählt ihr, wenn ihr WinForms benutzt Exceptionless.Windows aus oder wenn ihr WPF benutzt Exceptionless.Wpf aus. (Exceptionless wird automatisch installiert).


      Das folgende Problem: Exceptionless scheint ein wenig verbugt zu sein, weswegen wir ein bisschen was verändern müssen. Als erstes öffnet ihr die App.config aus eurer Projektmappe. Dort sollte folgende Zeile drinstehen:

      XML-Quellcode

      1. <exceptionless apiKey="API_KEY_HERE" />


      Löscht diese Zeile. Als nächstes geht ihr auf "Alle Dateien anzeigen".



      Nun klappt ihr My Project auf und öffnet AssemblyInfo.vb.



      Dort schreibt ihr folgendes dazu:

      VB.NET-Quellcode

      1. <Assembly: Exceptionless.Configuration.Exceptionless("EUER API KEY")>


      C#-Quellcode

      1. [assembly: Exceptionless.Configuration.Exceptionless("EUER API KEY")]



      Vergesst nicht, euren API Key einzutragen.

      Wenn ihr das habt müsst ihr Exceptionless nur noch "aktivieren". Das tut ihr mit folgender Zeile:

      VB.NET-Quellcode

      1. ExceptionlessClient.Current.Register()


      C#-Quellcode

      1. Exceptionless.ExceptionlessClient.Current.Register();


      WICHTIG: Ihr müsst den Exceptionless-Namespace importieren, da .Register() eine Erweiterung ist.

      Wichtig ist, dass diese Codezeile beim Starten der Anwendung ausgeführt wird. In C# kann diese Zeile somit in die Program.cs-Datei geschrieben werden (Oder bei VB.Net in die ApplicationEvents). Es ist außerdem möglich, diese Zeile in das Load-Event eines Formulares oder eines Windows zu schreiben, wobei ihr beim ändern des Startobjektes dieses berücksichtigen müsst.

      Als letztes müssen wir eine Fehlermeldung nur noch senden. Wie man global alle Fehlermeldungen sendet werde ich weiter unten beschreiben, hier zeige ich euch, wie ihr eine Fehlermeldung anhand eines einfachen Beispiels bekommt und senden könnt.

      VB.NET-Quellcode

      1. Try
      2. Dim o As IO.StreamReader()
      3. o.Read()
      4. Catch ex As Exception
      5. ex.ToExceptionless().Submit()
      6. ExceptionlessClient.Current.ProcessQueue()
      7. End Try


      Der Code sollte klar sein. Wie lassen einen Fehler enstehen, indem wir mit einem nicht vorhandenen StreamReader eine Zeile lesen. ToExceptionless() ist wieder eine Erweiterung. Mit .Submit() senden wir den Fehler. Fertig. Obwohl, man kann noch verschiedene Sachen mitsenden:

      VB.NET-Quellcode

      1. Dim ExToSend = ex.ToExceptionless()
      2. ExToSend.MarkAsCritical()
      3. ExToSend.SetUserDescription(txtDescription.Text)
      4. ExToSend.SetUserEmail(txtEmail.Text)
      5. ExToSend.SetUserName(txtUserName.Text)
      6. ExToSend.Submit()

      Es gibt noch mehr Dinge, guckt einfach mal im Objectbrowser oder mit der IntelliSense nach.

      Als letztes sei noch gesagt, dass das ganze asynchron verläuft, was heißt, dass wenn ihr einen Dialog machen wollt, der erscheint, wenn eine Fehlermeldung kommt und beim klicken auf Senden die Fehlermeldung sendet und sich schließt, die Fehlermeldung erst beim nächsten Start gesendet wird. Mit dem Code

      VB.NET-Quellcode

      1. ExceptionlessClient.Current.ProcessQueue()


      wird die Fehlermeldung (werden die Fehlermeldungen) gesendet.

      Joa, das wars eigentlich. Kommen wir nun zum globalen abfangen der Fehler.


      Alle Fehler catchen

      Bevor ihr jetzt anfangt um den Code in jeder Prozedur einen Try-Catch Block zu legen um den Fehler dann zu senden zeige ich euch, wie ihr die Fehler ganz einfach global abfangen könnt. Das ist leider bei jeder Technologie anders (VB + WinForms / VB + WPF / C# + WinForms / C# + WPF).


      -> VB + Windows Forms

      Ihr geht auf My Project -> Anwendung -> Anwendungsereignisse anzeigen



      Dort schreibt ihr folgendes hin:

      VB.NET-Quellcode

      1. AddHandler AppDomain.CurrentDomain.FirstChanceException, Sub(s, ex)
      2. 'ex.Exception.ToExceptionless().Submit()
      3. End Sub



      -> C# + Windows Forms

      Ihr scheibt folgendes in die Program.cs:

      C#-Quellcode

      1. AppDomain.CurrentDomain.FirstChanceException += (s, e) =>
      2. {
      3. //e.Exception.ToExceptionless().Submit();
      4. };




      -> VB + WPF

      Ihr geht wie bei WinForms zu My Project -> Anwendung -> Anwendungsereignisse anzeigen



      Jetzt wird es etwas komplizierter, da es nicht nur ein Event für alles gibt, sondern mehrere, die teilweise den gleichen Fehler senden.
      Spoiler anzeigen

      VB.NET-Quellcode

      1. Dim IsHandled As Boolean = False
      3. Private Sub AppDomain_UnhandledException(sender As Object, e As UnhandledExceptionEventArgs)
      4. OnExceptionOccurred(DirectCast(e.ExceptionObject, Exception))
      5. End Sub
      7. Private Sub Application_DispatcherUnhandledException(sender As Object, e As Windows.Threading.DispatcherUnhandledExceptionEventArgs) Handles Me.DispatcherUnhandledException
      8. e.Handled = True
      9. OnExceptionOccurred(e.Exception)
      10. End Sub
      12. Private Sub OnExceptionOccurred(ex As Exception)
      13. If Not IsHandled Then
      14. IsHandled = True
      15. 'ex.Exception.ToExceptionless().Submit()
      16. End If
      17. End Sub
      19. Private Sub Application_Startup(sender As Object, e As StartupEventArgs) Handles Me.Startup
      20. AddHandler MyDomain.UnhandledException, AddressOf AppDomain_UnhandledException
      21. End Sub


      Außerdem solltest ihr folgendes zu eurer App.config hinzufügen:

      XML-Quellcode

      1. <configuration>
      2. <runtime>
      3. <legacyUnhandledExceptionPolicy enabled="1"/>
      4. </runtime>
      5. </configuration>


      -> C# + WPF

      Eigentlich das gleiche wie in VB außer, dass das ganze in der App.xaml.cs stattfindet:

      Spoiler anzeigen

      C#-Quellcode

      1. public App()
      2. {
      3. AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
      4. Application.Current.DispatcherUnhandledException += Current_DispatcherUnhandledException;
      5. }
      7. void Current_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
      8. {
      9. OnExceptionOccurred(e.Exception);
      10. e.Handled = true;
      11. }
      13. void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
      14. {
      15. OnExceptionOccurred((Exception)e.ExceptionObject);
      16. }
      18. bool IsHandled = false;
      19. void OnExceptionOccurred(Exception ex)
      20. {
      21. if (!IsHandled)
      22. {
      23. IsHandled = true;
      24. //e.Exception.ToExceptionless().Submit();
      25. }
      26. }


      Für C# gilt das gleiche wie für VB.Net:
      Ihr solltet folgendes zu eurer App.config hinzufügen:

      XML-Quellcode

      1. <configuration>
      2. <runtime>
      3. <legacyUnhandledExceptionPolicy enabled="1"/>
      4. </runtime>
      5. </configuration>



      Schlusswort
      Dann wünsche ich euch gutes gelingen und viel Spaß. Wenn ihr fragen habt, nur raus damit, vielleicht kann ich euch ja helfen.
      Mfg
      Vincent

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VincentTB“ ()

      Was passiert, wenn die Anwendung nicht online ausgeführt wird? Kommt eine Exception für den User oder einfach stillschweigend unterdrückt?

      EDIT: Habe es gefunden:
      Q: What happens if my internet connection goes down?
      A: Exceptionless queues all error submissions to disk and will retry them later.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „WhitePage“ ()