I have a Windows service that crashes in an unhandled way with the exception System.AccessViolationException. I does happen in one of 1000 cases when trying to load a user profile (during impersonation). While I am interested in finding the solution more importantly is that I cannot capture this unhandled error - and terminate my service in a good way.
During start I have added this exeception handler:
AddHandler AppDomain.CurrentDomain.UnhandledException, AddressOf UnhandledException
If I hard code throw System.AccessViolationException as the same place in the code it is captured by my handler. But in the 1 out of 1000 calls the process is terminated and I can only see information about this in the event viewer.
Any ideas how to capture this?
Have you tried this?
Try
'your code
Catch ex As AccessViolationException
'write your ex.ToString() on a file or whatever
End Try
Related
Need help with some VB.net coding (NOT C or c++)
So far I'm using this code to catch errors for specific line(s) of codes:
Try
bla bla bla
Catch ex As Exception
msbox("Error: " & ex.message)
End Try
But sometimes the application stops due to an error where I don't have a catch; how do I on occasions like this call upon a specific Sub (catch the error) for ANY OTHER error in the ENTIRE application where the Sub will display the error message (where I also plan on sending my self an e-mail in that sub to notify me application has stopped)?
I'm not sure if it will conflict with all current Try/Catch commands in my application, but I would prefer to only catch the error on code that currently is not within a Catch handler.
Thank you so much!
This functionality is built into the VB application framework, which is enabled by default in WinForms applications. Open the Application page of the project properties, click the View Application Events button and add a handler for the UnhandledException event using the navigation bar at the top of the code window. Done!
The VB application framework hides some of the complexity of applications that you must implement yourself in C#. It includes a Startup event that you can handle instead of adding code to a Main method, a StartupNextInstance event to support single-instance apps with commandline arguments, multi-threaded splash screen functionality and more.
Regarding your emailing idea, just sure to add in a privacy notice before auto-emailing yourself anything in your apps; this can be a big bone of contention to users, & if an astute one catches it silently phoning home your rep is down the drain.
As for a global error handler, have a look here:
https://www.dotnetcurry.com/patterns-practices/1364/error-handling-dotnet-projects
In desktop application I have set up trivial
UI thread exception handler and similar
code reacting to UnhandledException
If someone wants the codez (nothing interesting there):
Namespace My
Partial Friend Class MyApplication
' Thread exception handler. Handles all unhandled exceptions on UI thread.
Private Sub UIThreadException(sender As Object, e As ThreadExceptionEventArgs)
CustomErrorHandler.Handle(e.Exception, "[UIThreadException]")
End Sub
' Handle the UI exceptions by showing a dialog box, and asking the user whether
' or not they wish to abort execution.
' NOTE: This exception cannot be kept from terminating the application - it can only
' log the event, and inform the user about it.
Private Sub CurrentDomain_UnhandledException(sender As Object,
e As UnhandledExceptionEventArgs)
Try
Dim ex As Exception = CType(e.ExceptionObject, Exception)
CustomErrorHandler.OnUnhandled(ex)
Catch exc As Exception
MsgBox(exc.ToString(), vbCritical, "Last resort error printout")
End Try
End Sub
End Class
End Namespace
Sometimes, there is a difference when I throw exception from Form1's ButtonOK_Click(...) event handler:
when launched as standalone (app.exe), then UIThreadException() is called as expected
when launched from inside Visual Studio (app.vshost.exe), then CurrentDomain_UnhandledException() is called in the same scenario (the same place in code as before, the same data), ignoring UIThreadException() handler
So in standalone exe, all works reliably, but during debugging session, falling into unhandled exception in the same cases is very annoying.
I could observe the same behavior in Visual Studio 2012 and 2015. If tested on trivial examples, it always works as expected also in debugging session. If code is more complex (exception thrown in nested call etc.) then UI thread exception handler gets ignored.
Was someone of you able to observe the same problem and found a solution?
The exception was thrown in OnLoad() event (and I did not notice it).
Some inexperienced coworker put SQL processing into OnLoad event handler instead of constructor or OnShow event handler. And this is where troubles begin. Yes, I've once been there.
Is there a simple way to catch all exceptions in your VB.NET applications? I'm interested in making it so that instead of my users seeing a runtime error, they just are told that an error occurred and to contact tech support, then the relevant error information is logged so our support team can look at it afterwards.
You can use the OnUnhandledException application event to catch (almost) every exception that wasn't handled by the code.
On the Project Properties window (double-click project file on the solution explorer or Project Menu -> [Project name] properties), the Application page has a "View Application Events" button that creates a new file in your project.
In that file there are some events that are fired at application level; one of those is the UnhandledException. Whatever you put there will be executed instead of the classic JIT dialog. The UnhandledExceptionEventArgs object has an Exception property with the unhandled exception object, and a ExitApplication property that decides if the application should exit or continue executing.
Namespace My
' The following events are available for MyApplication:
'
' Startup: Raised when the application starts, before the startup form is created.
' Shutdown: Raised after all application forms are closed. This event is not raised if the application terminates abnormally.
' UnhandledException: Raised if the application encounters an unhandled exception.
' StartupNextInstance: Raised when launching a single-instance application and the application is already active.
' NetworkAvailabilityChanged: Raised when the network connection is connected or disconnected.
Partial Friend Class MyApplication
Private Sub MyApplication_UnhandledException(sender As Object, e As Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs) Handles Me.UnhandledException
MessageBox.Show(e.Exception.ToString) '<-- the exception object
e.ExitApplication = True '<-- True if you want the application to close; false to continue - if it can
End Sub
End Class
End Namespace
Note that there are still some "über-exceptions" that can't be caught even with this method (out of memory for example), but this way you can log what exceptions are not being correctly handled on your code, or what scenarios are actualy happening that weren't considered at the beggining.
More info here
As a side note: don't rely too much on this event. This has to be for extremely exceptional cases, as what is caught here should be treated ASAP in the corresponding class/module/method. This is a helpful tool for debugging and test cases but having too much exceptions being handled by this event would be a sign of something wrong in your code.
It depends on what environment your application is running in. If you are using WPF or WinForms, you would launch your application using a main method instead of directly launching a form or page. Your main method should then wrap the calls to instantiate the UI in a try catch block.
So, for a WinForms Application, you could do something like this:
Sub Main
Try
Dim MainUI As New Form1
MainUI.Show()
Application.Run
Catch ex As Exception
'Do that fancy exception processing
End Try
End Sub
You can do something similar with WPF. But, WPF also supports an event model where you are notified of exceptions, very similar to the one that ASP.Net uses.
You will never be able to catch the StackOverflowException.
All the others for sure yes. I'm not familiar with VB, but it is easy to achieve in C#. For VB, I think the generic exeption handler could be
Try
...
Catch e As Exception
...
End Try
Of course this has to wrap all your code. You can find more for examples here.
If you have forms application, it is not practical to have the handler around Application.Run() as the only event handler. Keep it there, but add also two others:
When inside the form, and exception occurs, you want to keep execution in that context – keep the form open etc. For this purpose, use ThreadExceptionEventHandler.
And also, for case when application is irrepairably crashing on some problem, add handler to Dispatcher.UnhandledException event. It is last thing executed before the application ends. You can log the exception to disk for later investigation etc. Very useful.
Let's see some good resource how they are applied.
So I have a Visual Basic application created in Visual Studio 2013 and I am trying to find a way to gracefully handle unhandled exceptions. I have graceful failing covered pretty well in the application but want to plan for something I missed.
So, that said. Is there a way to not show a user an unhandled exception directly but rather trigger a function or class that will display a friendly message to the user and write the technical stuff to an error log?
UI frameworks typically have a default handler in their main event loop which raises an event if an exception is thrown inside the loop, but the details vary depending on the framework. If your application is WPF-based, unhandled exceptions on the UI thread will raise Application.DispatcherUnhandledException. If it is WinForms-based, unhandled exceptions on the UI thread will raise Application.ThreadException.
The .Net runtime will raise AppDomain.UnhandledException on exceptions that aren't handled anywhere on the call stack (such as from worker threads).
Assuming Winforms, try this:
On the 'Application' tab of the Project Properties window, click the 'View Application Events' button towards the bottom.
Within the partial class that's generated for you, create a sub like this:
Private Sub MyApplication_UnhandledException(ByVal sender As Object, ByVal e As Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs) Handles Me.UnhandledException
...
end sub
I'll leave the friendly message and logging to you.
I'm using VB 2010 Express and sometimes my code is just ignored, without any error notification. For example, I have this code at the end of the sub that handles me.Load:
counter = counter is a test line. mPlayer is an object from Toub's sound midi dll, defined like this:
Dim mPlayer As MyMediaPlayer.MyWinPlayer
mPlayer = New MyMediaPlayer.MyWinPlayer()
When the filename contains a valid midi file, it all works and the msgbox's are displayed. When the midi file is NOT valid, I would like an error to be generated or AudioLength to be NULL or some weird value. Instead, no error is triggered and the debugger just exits the sub.
More in detail: the debugger stops at the first breakpoint. Then, when I click 'Continue', the form is displayed, without the debugger ever reaching the other breakpoints or ever producing the MsgBox's.
Could you please explain how to make VB give me the error?
I'm not familiar with the library you are using but any exception due to an invalid file will originate from the MyWinPlayer.Open() method (function in vb-speak). So if an exception is thrown, you need to handle that exception inside of a try-catch. If your current sub does not handle the exception, then the exception will bubble up to the calling method and keep going until there is some place that the exception is handled.
A try-catch block would be something like this (I don't write a lot in vb.net anymore, the syntax may not be perfect):
Try
mPlayer.Open(filename);
Catch ex As Exception
'Do something with the exception
' (e.g. write a log, set a value, or display error message)
End Try
Despite what I have written in the code block above, I would encourage you not to catch a general Exception, and instead focus on the specific type of exception that could be thrown from the Open() method. The reason is you only want to handle exceptions that you know how to handle in the current method and let the other exceptions bubble up. You would need to look at the documentation for the library and see what type of exceptions could be throw and include them.
Another important thing to mention is unless you have a very good reason, do not use an empty catch block (I can't think of one at the moment, but I'm sure there are some very rare uses). An empty catch will just swallow the exception and not do anything with it. It won't even notify you that there was an exception.
Now if you don't handle any exception, the exception should bubble up all the way to the top of the call stack and the debugger should show an Unhandled Exception message and stop there. If it is not doing that then either you are swallowing the exception further down the call stack or you are running into the bug that is mentioned in the possible duplicate Hans Passant mentioned in his comment
MSDN has a pretty decent summary of exception handling in the .NET languages. I would encourage you to read more on the subject.