One of threads prevents .NET program from stopping completely. How to identify which one?

Question

I have a large application with lots of functions. Sometimes, when you close the main form - it exits smoothly. Other times the form closes, but the program remains running. Which debugging tools does Visual Studio 2010 provide for identifying misbehaving threads?

Answer 1

Your application will not exit until all threads that have IsBackground == false have finished.

You can use the Threads window when the VS debugger is attached to see which threads are still running.

VS Menu: Debug -> Windows -> Threads.

Answer 2

I wrote the following code to keep track of which threads I have created, and warn me if any of them havn't shut down, on exit.

It works flawlessly, and it has the advantage of naming the threads within the Visual Studio debugger, which makes things easier to debug.

To use it, call the following on every thread that you create manually:

Thread x; 
// Yada yada create the thread. 
// Make sure you set ".IsBackground" property to "true".
x.MyRememberThreadUntilShutdown("name which is visible in VS debugger");

Then, call the following on exit:

OnShutdownCheckThreadsForExit();

Here is the helper class:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;

    namespace MyShared.MyHelper
    {
        /// <summary>
        /// Helper classes for threads.
        /// </summary>
        public static class MyThread
        {
            /// <summary>
            /// Remembers a thread, until shutdown.
            /// On shutdown, we can double check that all of the threads we created have been shut down.
            /// </summary>
            /// <param name="thread">Thread we want to remember until shutdown.</param>
            /// <param name="newName">New name for thread.</param>
            public static void MyRememberThreadUntilShutdown(this Thread thread, string newName)
            {
                // Check whether the thread has previously been named
                // to avoid a possible InvalidOperationException.
                if (thread.Name == null)
                {
                    thread.Name = "MyThread" + newName;
                }
                else
                {
                    Console.Write("Error E20120118-1914. Unable to rename thread to \"{0}\" as it already has a name of \"{1}\".\n",
                        newName, thread.Name);
                }

                ThreadList[newName] = thread;
            }

            /// <summary>
            /// This stores a list of all the threads we have running in the entire system.
            /// </summary>
            private static readonly Dictionary<string, Thread> ThreadList = new Dictionary<string, Thread>(); 

            /// <summary>
            /// On program exit, check that all of the threads we started have been exited.
            /// </summary>
            public static bool OnShutdownCheckThreadsForExit()
            {
                if (ThreadList.Count != 0)
                {
                    foreach (var thread in ThreadList)
                    {
                        if (thread.Value.IsAlive)
                        {
                            Console.Write("Error E20120119-8152. Thread name \"{0}\" was not shut down properly on exit.\n",thread.Key);
                        }
                    }
                    return false;
                }
                else
                {
                    return true;
                }
            }
        }
    }

Answer 3

If it closes sometimes smoothly and not at other times.. I would look to see how you are freeing or releasing objects and or exiting the application.. do you have any code for example where it would read

Environment.Exit(0); for example..?

Answer 4

Recently I realized, that you can also use the Debug Location toolbar to watch running threads. This is also very handy when you want to see what particular method / operation the thread is currently executing.

For the purpose of easy identification you may want to set the Name property of your Thread object. Mostly I use the this as prefix, followed by the method invoked by the thread.

 var thread = new Thread(...) { Name = this + ".Connect" };

Answer 5

You could loop through all the open threads and close them.

Do so by: Process.GetCurrentProcess().Threads

Another alternative would be to terminate the process:

Process.GetCurrentProcess().Kill();