The ultimate solution to let the program exit in a decent way when it crashes (seh + dump + unhandled exception filter)

Http://blog.csdn.net/starlee/article/details/6655779

--------------------------------------------------

In my previous articleArticleSeh + dump file for decent exit in case of program crash I introduced how to avoid using seh + dump fileProgramAnd create a dump file when the program crashes to help locate exceptionsCodeLine. However, only the code in the try/try t block has an exception can be captured. The code outside the try block has an exception and the program will crash.
The following uses the code in seh + dump file, which causes the program to exit in a decent way when it crashes, as an example.

View plainprint?

2. // Create a dump file
4. //
6. VoidCreatedumpfile (LpcwstrLpstrdumpfilepathname, exception_pointers * pexception)
8. {
10. // Create a dump file
12. //
14. HandleHdumpfile = createfile (lpstrdumpfilepathname, generic_write, 0, null, create_always, file_attribute_normal, null );
18. // Dump Information
20. //
22. Minidump_exception_information dumpinfo;
24. Dumpinfo. exceptionpointers = pexception;
26. Dumpinfo. threadid = getcurrentthreadid ();
28. Dumpinfo. clientpointers = true;
32. // Write the dump file content
34. //
36. Minidumpwritedump (getcurrentprocess (), getcurrentprocessid (), hdumpfile, minidumpnormal, & dumpinfo, null, null );
40. Closehandle (hdumpfile );
42. }
46. // Function used as an expression in blocks t
48. //
50. LongCrashhandler (exception_pointers * pexception)
52. {
54. // Add the code for handling program crashes here
56. //
60. // Here is an example of a pop-up dialog box.
62. //
64. MessageBox (null, _ T ("Message from catch handler"), _ T ("Test"), Mb_ OK );
68. // Create a dump file
70. //
72. Createdumpfile (_ T ("C: \ test. dmp"), Pexception );
76. ReturnPrediction_execute_handler;
78. }
82. Int_ Tmain (IntArgc, _ tchar * argv [])
84. {
86. _ Try
88. {
90. MessageBox (null, _ T ("Message from '_ try' section"), _ T ("Test"), Mb_ OK );
94. // In addition to zero, the program crashes manually
96. //
98. IntI = 13;
100. IntJ = 0;
102. IntM = I/J;
104. }
106. // Create a dump file when an exception that causes the program to crash
108. //
110. _ Random t (crashhandler (getexceptioninformation ()))
112. {
114. // Here is an example of a pop-up dialog box.
116. //
118. MessageBox (null, _ T ("Message from '_ partition t' section"), _ T ("Test"), Mb_ OK );
120. }
124. MessageBox (null, _ T ("Funcation completed"), _ T ("Test"), Mb_ OK );
128. Return0;
130. }

// Create a dump file <br/> // <br/> void createdumpfile (lpcwstr lpstrdumpfilepathname, exception_pointers * pexception) <br/>{< br/> // create a dump file <br/> // <br/> handle hdumpfile = createfile (lpstrdumpfilepathname, generic_write, 0, null, create_always, file_attribute_normal, null); </P> <p> // dump Information <br/> // <br/> minidump_exception_information dumpinfo; <br/> dumpinfo. exceptionpointers = pexception; <br/> dumpinfo. threadid = getcurrentthreadid (); <br/> dumpinfo. clientpointers = true; </P> <p> // write the dump file content <br/> // <br/> minidumpwritedump (getcurrentprocess (), getcurrentprocessid (), hdumpfile, minidumpnormal, & dumpinfo, null, null); </P> <p> closehandle (hdumpfile ); <br/>}</P> <p> // function used as an expression in blocks of blocks <br/> // <br/> long crashhandler (exception_pointers * pexception) <br/>{< br/> // Add the code for handling program crashes here <br/> // </P> <p> // a dialog box is displayed. for example <br/> // <br/> MessageBox (null, _ T ("Message from catch handler"), _ T ("test"), mb_ OK ); </P> <p> // create a dump file <br/> // <br/> createdumpfile (_ T ("C: \ test. DMP "), pexception); </P> <p> return exception_execute_handler; <br/>}</P> <p> int _ tmain (INT argc, _ tchar * argv []) <br/>{< br/>__ try <br/>{< br/> MessageBox (null, _ T ("Message from '_ try' section"), _ T ("test"), mb_ OK); </P> <p> // division by zero, manual program crash <br/> // <br/> int I = 13; <br/> Int J = 0; <br/> int M = I/J; <br/>}< br/> // capture the dump file created when an exception that causes the program to crash <br/> // <br/>__ handler T (crashhandler (getexceptioninformation () )) <br/>{< br/> // here, a dialog box is displayed as an example <br/> // <br/> MessageBox (null, _ T ("Message from '_ partition t' section"), _ T ("test"), mb_ OK ); <br/>}</P> <p> MessageBox (null, _ T ("funcation completed"), _ T ("test"), mb_ OK ); </P> <p> return 0; <br/>}

Compile and run the above Code. The following dialog box is displayed in sequence, and a dump file test. DMP is created on drive C.

If you change the main () function in the above Code to the following, the compiled program will crash.

View plainprint?

2. Int_ Tmain (IntArgc, _ tchar * argv [])
4. {
6. _ Try
8. {
10. MessageBox (null, _ T ("Message from '_ try' section"), _ T ("Test"), Mb_ OK );
14. // In addition to zero, the program crashes manually
16. //
18. IntI = 13;
20. IntJ = 0;
22. IntM = I/J;
24. }
26. // Create a dump file when an exception that causes the program to crash
28. //
30. _ Random t (crashhandler (getexceptioninformation ()))
32. {
34. // Here is an example of a pop-up dialog box.
36. //
38. MessageBox (null, _ T ("Message from '_ partition t' section"), _ T ("Test"), Mb_ OK );
40. }
44. // In addition to zero, the program crashes manually
46. //
48. IntI = 13;
50. IntJ = 0;
52. IntM = I/J;
56. MessageBox (null, _ T ("Funcation completed"), _ T ("Test"), Mb_ OK );
60. Return0;
62. }

int _ tmain (INT argc, _ tchar * argv []) <br/>{< br/>__ try <br/>{< br/> MessageBox (null, _ T ("Message from '_ try' section "), _ T ("test"), mb_ OK); </P> <p> // division by zero, manual program crash <br/> // <br/> int I = 13; <br/> Int J = 0; <br/> int M = I/J; <br/>}< br/> // capture the dump file created when an exception that causes the program to crash <br/> // <br/>__ handler T (crashhandler (getexceptioninformation () )) <br/>{< br/> // here, a dialog box is displayed as an example <br/> // <br/> MessageBox (null, _ T ("Message from '_ partition t' section"), _ T ("test"), mb_ OK ); <br/>}</P> <p> // The program crashes manually after division by zero. <br/> // <br/> int I = 13; <br/> Int J = 0; <br/> int M = I/J; </P> <p> MessageBox (null, _ T ("funcation completed "), _ T ("test"), mb_ OK); </P> <p> return 0; <br/>}

This situation is very likely to occur in actual programming. After all, we cannot predict all possible causes of program crash in advance and put the code into try/retry t blocks. So what should we do with these unpredictable exceptions? This will use the method in my unhandled exception that causes a program to exit in a decent way when it crashes: Use setunhandledexceptionfilter in the Windows API to set a callback function to handle these unexpected exceptions. The following is the modified Code in the above example code. The createdumpfile function does not change.

View plainprint?

2. // Obtain the current time
4. //
6. Wstring getpresenttime ()
8. {
10. Systemtime time;
12. Getlocaltime (& time );
16. Wchar_tWsztime [128];
18. Swprintf_s (wsztime, _ T ("% 04d-% 02d-% 02d % 02d-% 02d-% 02d-% 03d"), Time. wyear, time. wmonth, time. wday, time. whour, time. wminute, time. wsecond, time. wmilliseconds );
22. ReturnWstring (wsztime );
24. }
28. // Callback function for Exception Handling
30. //
32. LongCrashhandler (exception_pointers * pexception)
34. {
36. // Add the code for handling program crashes here
38. //
42. // Here is an example of a pop-up dialog box.
44. //
46. MessageBox (null, _ T ("Message from catch handler"), _ T ("Test"), Mb_ OK );
50. // Use the current time as the file name
52. //
54. Wstring strdumpfilename = _ T ("C: \") + getpresenttime () + _ T (". Dmp ");
58. // Create a dump file
60. //
62. Createdumpfile (strdumpfilename. Data (), pexception );
66. ReturnPrediction_execute_handler;
68. }
72. Int_ Tmain (IntArgc, _ tchar * argv [])
74. {
76. // Set the callback function for processing unhandled exception
78. //
80. Setunhandledexceptionfilter (lptop_level_exception_filter) crashhandler );
84. _ Try
86. {
88. MessageBox (null, _ T ("Message from '_ try' section"), _ T ("Test"), Mb_ OK );
92. // In addition to zero, the program crashes manually
94. //
96. IntI = 13;
98. IntJ = 0;
100. IntM = I/J;
102. }
104. _ Random t (crashhandler (getexceptioninformation ()))
106. {
108. // Add the code for handling program crashes here
110. //
114. // Here is an example of a pop-up dialog box.
116. //
118. MessageBox (null, _ T ("Message from '_ partition t' section"), _ T ("Test"), Mb_ OK );
120. }
124. // In addition to zero, the program crashes manually
126. //
128. IntI = 13;
130. IntJ = 0;
132. IntM = I/J;
136. MessageBox (null, _ T ("Funcation completed"), _ T ("Test"), Mb_ OK );
140. Return0;
142. }

// <Br/> obtain the current time <br/> // <br/> wstring getpresenttime () <br/>{< br/> systemtime time; <br/> getlocaltime (& time); </P> <p> wchar_t wsztime [128]; <br/> swprintf_s (wsztime, _ T ("% 04d-% 02d-% 02d % 02d-% 02d-% 02d-% 03d"), <br/> time. wyear, time. wmonth, time. wday, time. whour, time. wminute, <br/> time. wsecond, time. wmilliseconds); </P> <p> return wstring (wsztime ); <br/>}</P> <p> // callback function for exception handling <br/> // <br/> long crashhandler (exception_pointers * pexception) <br/>{< br/> // Add the code for handling program crashes here <br/> // </P> <p> // a dialog box is displayed. for example <br/> // <br/> MessageBox (null, _ T ("Message from catch handler"), _ T ("test"), mb_ OK ); </P> <p> // use the current time as the file name <br/> // <br/> wstring strdumpfilename = _ T ("C :\\") + getpresenttime () + _ T (". DMP "); </P> <p> // create a dump file <br/> // <br/> createdumpfile (strdumpfilename. data (), pexception); </P> <p> return exception_execute_handler; <br/>}</P> <p> int _ tmain (INT argc, _ tchar * argv []) <br/>{< br/> // set the callback function for processing unhandled exception <br/> // </P> <p> setunhandledexceptionfilter (lptop_level_exception_filter) crashhandler ); </P> <p >__ try <br/> {<br/> MessageBox (null, _ T ("Message from '_ try' section "), _ T ("test"), <br/> mb_ OK); </P> <p> // division by zero, manual program crash <br/> // <br/> int I = 13; <br/> Int J = 0; <br/> int M = I/J; <br/>}< br/>__ handle T (crashhandler (getexceptioninformation ())) <br/>{< br/> // Add the code for handling program crashes here <br/> // </P> <p> // a dialog box is displayed. for example <br/> // <br/> MessageBox (null, _ T ("Message from '_ partition t' section"), _ T ("test"), <br/> mb_ OK ); <br/>}</P> <p> // The program crashes manually after division by zero. <br/> // <br/> int I = 13; <br/> Int J = 0; <br/> int M = I/J; </P> <p> MessageBox (null, _ T ("funcation completed "), _ T ("test"), mb_ OK); </P> <p> return 0; <br/>}

Compile the above Code and run the generated EXE file. You can see that the program Exits normally after the series of dialogs mentioned above are popped up. At the same time, two dump files are generated under drive C, and the file name indicates the time when an exception occurs.

The above code is only to illustrate how to use seh and setunhandledexceptionfilter together, so the expressions after the limit T and
The callback function set in setunhandledexceptionfilter uses the same function crashhandler. In actual applications
Use different functions as required. The parameter of this function must be a pointer to prediction_pointers, and the returned value must be one of the three
Nodes: prediction_continue_search, prediction_continue_execution, and prediction_execute_handler.
For the specific meanings of these three values, refer to msdn or my article "seh for decent exit when a program crashes".

In practice, the same callback function should not be used. Because the function in the limit t expression is used to handle code exceptions in the try block.
The callback function set by setunhandledexceptionfilter is used to handle exceptions that are not captured in the code. For exceptions that are not captured, this callback function is not
If you know where an exception occurs, you can know the exception type through the Exception Code, but you cannot handle the exception because you do not know what the exception is. Generally, this callback function
Number is the last line of defense before the application crashes. After the code in this function is executed, the application will be terminated. Therefore, in most applications, an error report is displayed in this function.
Dialog Box to tell the user that the program has an exception and needs to be terminated. You can send the error report (usually including the dump file and some necessary text information) to a specified place to help developers modify code defects
Improve software quality.

the application compiled using the preceding method will not crash and a dump file will be generated when an exception occurs. Program users will have a very good user experience. If you add log information to the application and use the dump file together, you can easily locate exceptions in the application and help developers quickly fix errors in the code.