Using Keyword Can Cause Bugs

namespace TestApplication
{
	class Program
	{
		static void Main(string[] args)
		{
			Program value1 = null;
			Program value2 = null;
			try
			{
				value1 = new Program();
				GC.KeepAlive(value1);
				value2 = new Program();
				GC.KeepAlive(value2);
			}
			finally
			{
				Console.WriteLine(value1);
				Console.WriteLine(value2);
			}
		}
	}
}

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       54 (0x36)
  .maxstack  1
  .locals init ([0] class TestApplication.Program value1,
           [1] class TestApplication.Program value2)
  IL_0000:  nop
  IL_0001:  ldnull
  IL_0002:  stloc.0
  IL_0003:  ldnull
  IL_0004:  stloc.1
  .try
  {
    IL_0005:  nop




// this is the allocation.
    IL_0006:  newobj     instance void TestApplication.Program::.ctor()





// this is the assignment. Imagine the abort cames between IL_0006 and IL_000b
    IL_000b:  stloc.0



    IL_000c:  ldloc.0
    IL_000d:  call       void [mscorlib]System.GC::KeepAlive(object)
    IL_0012:  nop

// again, first the allocation.
    IL_0013:  newobj     instance void TestApplication.Program::.ctor()


// and then the assignment.
    IL_0018:  stloc.1


    IL_0019:  ldloc.1
    IL_001a:  call       void [mscorlib]System.GC::KeepAlive(object)
    IL_001f:  nop
    IL_0020:  nop
    IL_0021:  leave.s    IL_0034
  }  // end .try
  finally
  {

// this block may not dispose the items, but it shows how the variables are get from the ldloc.0 and ldloc.1, which are stored just AFTER the allocation.

    IL_0023:  nop
    IL_0024:  ldloc.0
    IL_0025:  call       void [mscorlib]System.Console::WriteLine(object)
    IL_002a:  nop
    IL_002b:  ldloc.1
    IL_002c:  call       void [mscorlib]System.Console::WriteLine(object)
    IL_0031:  nop
    IL_0032:  nop
    IL_0033:  endfinally
  }  // end handler
  IL_0034:  nop
  IL_0035:  ret
} // end of method Program::Main

Paulo Zemek wrote:

// this is the allocation.
IL_0006: newobj instance void TestApplication.Program::.ctor()

// this is the assignment. Imagine the abort cames between IL_0006 and IL_000b
IL_000b: stloc.0

class Program : IDisposable
{
	static void Main(string[] args)
	{
		using (Program something = new Program())
		{
		}
	}
	public void Dispose()
	{
	}
}

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       19 (0x13)
  .maxstack  1
  .locals init ([0] class ConsoleApplication1.Program something)


  ///////////////// The constructor and assignment is called before the try is entered.
  IL_0000:  newobj     instance void ConsoleApplication1.Program::.ctor()
  IL_0005:  stloc.0



  .try
  {
    IL_0006:  leave.s    IL_0012
  }  // end .try
  finally
  {
    IL_0008:  ldloc.0
    IL_0009:  brfalse.s  IL_0011
    IL_000b:  ldloc.0
    IL_000c:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
    IL_0011:  endfinally
  }  // end handler
  IL_0012:  ret
} // end of method Program::Main

  // in theory there is an if (transaction != null) here, 
  // but I think optimization will remove it.

aspdotnetdev wrote:

This is the reason that the finally block doesn't have an if statement.

using System;
using System.Threading;

namespace TestApplication
{
	class Program
	{
		private static int fCount;
		private sealed class IncreaseDecrease:
			IDisposable
		{
			public IncreaseDecrease()
			{
				Interlocked.Increment(ref fCount);
			}
			public void Dispose()
			{
				Interlocked.Decrement(ref fCount);
			}
		}
		
		
		static void Main(string[] args)
		{
			while(true)
			{
				Thread thread1 = new Thread(p_Run);
				thread1.Start();


				Thread thread2 = new Thread(p_Run);
				thread2.Start();

				Thread thread3 = new Thread(p_Run);
				thread3.Start();

				Thread.Sleep(0);

				thread1.Abort();
				thread2.Abort();
				thread3.Abort();

				thread1.Join();
				thread2.Join();
				thread3.Join();

				int result = Interlocked.Exchange(ref fCount, 0);
				if (result != 0)
					throw new Exception("The Abort happened in the wrong place! " + result);
			}
		}
		
		private static void p_Run()
		{
			while(true)
				using(var x = new IncreaseDecrease())
					GC.KeepAlive(x);

			// try using the other approach:
			/*while (true)
			{
				IDisposable x = null;
				try
				{
					try
					{
					}
					finally
					{
						x = new IncreaseDecrease();
					}
					
					GC.KeepAlive(x);
				}
				finally
				{
					if (x != null)
						x.Dispose();
				}
			}*/
		}
	}
}

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

namespace ConsoleApplication1
{
	class Program
	{
		private static int fCount = 0;
		private sealed class IncreaseDecrease : IDisposable
		{
			private bool decrement;
			public IncreaseDecrease()
			{
				try
				{
				}
				finally
				{
					Interlocked.Increment(ref fCount);
					decrement = true;
				}
			}
			public void Dispose()
			{
				try
				{
				}
				finally
				{
					if (decrement)
					{
						Interlocked.Decrement(ref fCount);
					}
					else
					{
						// This appears to never happen, but is here just in case.
						System.Console.Out.WriteLine("Constructor aborted before incrementing.");
					}
				}
			}
		}

		static void Main(string[] args)
		{
			ThreadStart scenario = null;
			while (scenario == null)
			{
				System.Console.Out.WriteLine("Which would you like to demonstrate:");
				System.Console.Out.WriteLine("1 - Problem (using)");
				System.Console.Out.WriteLine("2 - Potential Solution (try{...}finally{...})");
				System.Console.Out.WriteLine("3 - Solution (try{try{...}finally{...}}finally{...})");
				string choice = System.Console.In.ReadLine();
				switch (choice)
				{
					case "1":
						scenario = new ThreadStart(Problem);
						break;
					case "2":
						scenario = new ThreadStart(PotentialSolution);
						break;
					case "3":
						scenario = new ThreadStart(Solution);
						break;
					default:
						scenario = null;
						break;
				}
			}
			while (true)
			{
				Thread thread1 = new Thread(scenario); thread1.Start();
				Thread thread2 = new Thread(scenario); thread2.Start();
				Thread thread3 = new Thread(scenario); thread3.Start();
				Thread.Sleep(0);
				thread1.Abort();
				thread2.Abort();
				thread3.Abort();
				thread1.Join();
				thread2.Join();
				thread3.Join();
				if (fCount != 0)
				{
					fCount = 0;
					System.Console.Out.WriteLine("The Abort happened in the wrong place!");
				}
				else
					System.Console.Out.WriteLine("Nothing out of the ordinary");
			}
		}
		private static void Problem()
		{
			while (true) using (var x = new IncreaseDecrease()) GC.KeepAlive(x);
		}

		private static void PotentialSolution()
		{
			IDisposable x = null;
			try
			{
				x =
					// Abort can happen after construction, but before assignment? Not so sure...
					new IncreaseDecrease();
				GC.KeepAlive(x);
			}
			finally
			{
				if (x != null) x.Dispose();
			}
		}
		
		private static void Solution()
		{
			while (true)
			{
				IDisposable x = null;
				try
				{
					try
					{
					}
					finally
					{
						x = new IncreaseDecrease();
					}
					GC.KeepAlive(x);
				}
				finally
				{
					if (x != null) x.Dispose();
				}
			}
		}

	}
}

          FileStream file2 = null;
          try
          {
            try
            {
            }
            finally
            {
              file2 = File.Create("c:\\Created.txt");
            }

            GC.KeepAlive(file2);
          }
          catch (Exception ex)
          {
            if (ex is System.IO.IOException)
              throw new Exception();
          }
          //finally
          //{
          //  if (file2 != null)
          //    file2.Dispose();
          //}

          FileStream file2 = null;
          try
          {
            try
            {
            }
            finally
            {
              file2 = File.Create("c:\\Created.txt");
            }

            GC.KeepAlive(file2);
          }
          catch (Exception ex)
          {
            if (ex is System.IO.IOException)
              throw new Exception();
          }
          finally
          {
            if (file2 != null)
              file2.Dispose();
          }

ReaderWriterLock rwl = /*…*/;
bool taken = false;
try
{
  try {}
  finally
  {
    rwl.AcquireWriterLock(-1);
    taken = true;
  }
  // do some work
}
finally
{
  if (taken)
    rwl.ReleaseWriterLock();
}