Btukfyl

I'm starting a thread like this:

nameOfThread = new Thread(() => 

{

    //do stuff

});

nameOfThread.Start();

At some point inside this anonymous function I open a WinSCP session like this:

using (Session session = new Session())

{

     //do stuff

}

If I abort the thread (from somewhere else) like this nameOfThread.Abort() while still doing stuff inside using, is the session disposed at the end?

Most likely it will, but you can't be sure.

According to the documentation:

When this method [Abort] is invoked on a thread, the system throws a ThreadAbortException in the thread to abort it.

And we know exceptions will still let using statements dispose, as they should. (Give and take a few exceptions)

On the other hand, if you can end the thread gracefully, for example with a CancellationTokenSource, it would be a lot nicer for your app. It will offer much more control over the actual termination of your thread and the handling of exceptions.

I answered you can guarantee that the using statement will always call Dispose and I stand corrected, I was wrong.

There is a potential race condition with the using statement that doesn't guarantee disposing and I've put together a console app illustrating this (which isn't hard or trivial).

I was correct when showing how the IL generates using like so:

var session = new Session(); //If this causes an error or abort happens during initialization then we don't enter try

//If abort is called here then we never enter try

//In either case above we may have undisposed resources initialized at this point

try

{

    //do stuff

}

finally

{

    session.Dispose();

}   

However; note the comments where I show the race condition that may occur if aborted before entering try.

Here is a console app written just to prove this point. The first works as expected but if you add the commented out code //thread.Abort() when we initialize R then you will see it init but never dispose :/

using System;

using System.Threading;



namespace Question_Answer_Console_App

{

    class Program

    {

        static void Main(string args)

        {

            Console.WriteLine("Start Main");



            Thread thread = null;

            thread = new Thread(new ThreadStart(() =>

            {

                Console.WriteLine("Thread Started");

                using (var r = new R(thread))

                {

                    Console.WriteLine($"Using {nameof(R)}");

                }

            }));



            thread.Start();

            thread.Join();



            Console.WriteLine("End Main");

            Console.ReadKey();

        }

    }



    public class R : IDisposable

    {

        public R(Thread thread)

        {

            Console.WriteLine($"Init {nameof(R)}");

            //thread.Abort();

        }



        public void Dispose()

        {

            Console.WriteLine($"Disposed {nameof(R)}");

        }

    }

}

Output with //thread.Abort() commented out:

Start Main

Thread Started

Init R

Using R

Disposed R

End Main

Output with thread.Abort() not commented out:

Start Main

Thread Started

Init R

End Main