I am in support team of one legacy VB6 project that involves socket communication.
We got one issue in error handling.
Following are the components of this application.
Main process
Activex Exe process
Main process creates the activex class objects and invokes functions and consumes events (like socket connected,reading etc ) from those objects.
Main process form module have error handlers in all functions.
Main process error handler does following:
Log error in file
Show Msgbox (vbcritical style) to user
In ActiveX exe class,all functions have error handlers
ActiveX process error handler does following
Log error in file
Raise error using Err.raise
We observed when a function of ActiveX class invoked from main process and some error occurs in ActiveX exe function, a runtime error message is displayed from activex exe and ActiveX process terminated even though
error handlers are there in Main process functions.
Is there something wrong in error handlers design or error handlers in one process cannot catch the errors raised in other process?
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
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.
I'm creating an add-in for Solidworks EPDM (example from API help). This is a class library (.dll) project which is added to EPDM and allows some custom functions to be added to the program.
I want to add logging for unhandled errors so that when an exception is caused by my add-in (as opposed to by the Solidworks EPDM program itself) I can be notified of it and try to fix it.
I'm quite new to all of this (and by all of this I mean VB.NET as a language, programming anything other than macros in VBA, structured exception handling, error logging, etc) and I'm trying to follow MSDN How To: Log Exceptions in Visual Basic but the instructions for logging unhanlded exceptions don't seem applicable to class library projects.
Specifically, I don't know how to get past step 3:
To log an unhandled exception
1. Have a project selected in Solution Explorer. On the Project menu, choose Properties.
2. Click the Application tab.
3. Click the View Application Events button to open the Code Editor.
This opens the ApplicationEvents.vb file.
The View Application Events button is greyed out for class library projects.
So, is there another way to add logging for unhandled exceptions in class library projects? Or, another way to access the ApplicationEvents.vb file for class library objects? I've tried searching for either, and have yet to find a solution that would allow me to log unhandled exceptions.
This is a very basic example but wrap your code with Try/Catch in the only two interface methods (host "callbacks") that IEdmAddIn5 defines and which your add-in class must implement.
Public Sub GetAddInInfo(ByRef poInfo As EdmAddInInfo, ByVal poVault As IEdmVault5, ByVal poCmdMgr As IEdmCmdMgr5) Implements IEdmAddIn5.GetAddInInfo
Try
...
Catch ex As Exception
' Handle exception...
End Try
End Sub
Public Sub OnCmd(ByRef poCmd As EdmCmd, ByRef ppoData As System.Array) Implements IEdmAddIn5.OnCmd
Try
...
Catch ex As Exception
' Handle exception...
End Try
End Sub
I would ordinarily agree with #Hans Passant about re-throwing the exception but I generally have found that to be problematic with an EPDM add-ins as it can cause the COM host to crash.
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 am coding a DLL in C++/CLI that is called in a C# based GUI application. I throw a custom exception (derived from Exception class), which, if not swallowed in my DLL, is handled in the final catch block in the GUI code. It works well for all throws, save one:
Im my DLL I have implemented a handler that will listen to SerialPort::DataReceived events. If I get an incorrect packet, I raise a custom exception, which is rethrown in the outermosst try-catch block. The GUI is supposed to display this custom exception. But for some reason an exception raised in this block is not re-thrown. Instead I get an "Unhandled exception" message in Debug mode. When I run the exe directly by double clicking the exe (in release folder) it simply crashes. Apparently, exceptions raised in this event handler method are not handled by the GUI. Or maybe they are not passed to the GUI from my DLL. It doesnt create a problem for other parts of my dll. The only reason I can think for this different behaviour is that the event handler doesn't have a caller. Is my guess correct? or is there some other reason. Any clues on how I can handle this problem? I dont want my application to crash. I just want to raise an exception so that the message can be displayed to the user in the GUI and the application can stop communicating with the serial port.
You need to switch to the UI thread before throwing from that event handler. This is typically accomplished with System::Threading::SynchronizationContext, but if you're using WinForms you can alternatively use System::Windows::Forms::Control::BeginInvoke or System::Windows::Forms::Control::Invoke.