The Weird and The Wonderful

Dave Kreskowiak wrote:

The C# script would be compiled and executed without generating an .EXE on disk. It would all be in-memory.

Dave Kreskowiak wrote:

Yep, and it was ugly and included certain restrictions on how the code had to be written.

Super Lloyd wrote:

.NET.. err.. 4.7?

void Foo()
{
    int Bar() => 42;
    Console.WriteLine(Bar());
}

[CompilerGenerated]
internal static int <Foo>g__Bar|0_0()
{
    return 42;
}

void Foo()
{
    Console.WriteLine(<Foo>g__Bar|0_0());
}

using (SomeResource res = new SomeResource())
{
  //using block
}
//-------------
SomeResource res = new SomeResource();
try
{
  //using block
}
finally
{
  if (res != null)
     ((IDisposable)res).Dispose();
}

class Test : IDisposable
{
    public Test() => throw new NotImplementedException();

    public void Dispose() {}
}

using (Test t = new Test())
{
    Console.WriteLine("constructor exception swallowed.");
}

Quote:

Code written with a using block is going to be significantly more "correct" than code that eschews it in favour of manual clean-up.

namespace UsingTest
{
	public class DisposableClass : IDisposable
	{

		private Boolean m_blnDisposeHasBeenCalled = false;

		public DisposableClass()
		{
			Int32 denom = 20;
			Int32 numer = 0;
			Int32 result = denom / numer;

		}

		public String WhoIsIt()
		{
			return $"{Environment.UserDomainName}\\{Environment.UserName} on {Environment.MachineName} from {Environment.CurrentDirectory} on thread ID {Environment.CurrentManagedThreadId.ToString()}.";
		}

		#region IDisposable Implementation

		/// <summary>
		/// Implement the IDisposable.Dispose() method
		/// Developers are supposed to call this method when done with this Object.
		/// There is no guarantee when or if the GC will call it, so 
		/// the developer is responsible to.  GC does NOT clean up unmanaged 
		/// resources, such as COM objects, so we have to clean those up, too.
		/// 
		/// </summary>
		public void Dispose()
		{
			try
			{
				// Check if Dispose has already been called 
				// Only allow the consumer to call it once with effect.
				if (!m_blnDisposeHasBeenCalled)
				{
					// Call the overridden Dispose method that contains common cleanup code
					// Pass true to indicate that it is called from Dispose
					Dispose(true);

					// Prevent subsequent finalization of this Object. This is not needed 
					// because managed and unmanaged resources have been explicitly released
					GC.SuppressFinalize(this);
				}
			}
			catch (Exception exUnhandled)
			{
				exUnhandled.Data.Add("m_blnDisposeHasBeenCalled", m_blnDisposeHasBeenCalled.ToString());
				throw;
			}
		}

		/// <summary>
		/// Explicit Finalize method.  The GC calls Finalize, if it is called.
		/// There are times when the GC will fail to call Finalize, which is why it is up to 
		/// the developer to call Dispose() from the consumer Object.
		/// </summary>
		~DisposableClass()
		{
			// Call Dispose indicating that this is not coming from the public
			// dispose method.
			Dispose(false);
		}

		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
		public void Dispose(Boolean disposing)
		{
			try
			{
				// Here we dispose and clean up the unmanaged objects and managed Object we created in code
				// that are not in the IContainer child Object of this object.
				// Unmanaged objects do not have a Dispose() method, so we just set them to null
				// to release the reference.  For managed objects, we call their respective Dispose()
				// methods and then release the reference.
				// DEVELOPER NOTE:
				//if (m_obj != null)
				//    {
				//    m_obj = null;
				//    }

				// Set the flag that Dispose has been called and executed.
				m_blnDisposeHasBeenCalled = true;
			}
			catch (Exception exUnhandled)
			{
				exUnhandled.Data.Add("m_blnDisposeHasBeenCalled", m_blnDisposeHasBeenCalled.ToString());
				throw;
			}
		}
		#endregion IDisposable Implementation
	}
}

[TestMethod]
public void UsingStatementTest()
{
    try
    {
        using (DisposableClass test = new())
        {
            try
            {
                String result = test.WhoIsIt();
            }
            catch (Exception ex)
            {
                Assert.Fail($"INNER: {ex.Message}");
            }
        }
    }
    catch (Exception exOuter)
    {
        Assert.Fail($"OUTER: {exOuter.Message}");
    }
}

[TestMethod]
public void StandardUsageTest()
{

    DisposableClass test = null;

    try
    {
        test = new();

        String result = test.WhoIsIt();
    }
    catch (Exception exOuter)
    {
        Assert.Fail($"ONLY: {exOuter.Message}");
    }
    finally
    {
        test?.Dispose();
    }
}

.try
{
  IL_0000:  newobj     instance void [UsingTest]UsingTest.DisposableClass::.ctor()
  IL_0005:  stloc.0
  .try
  {
    .try
    {
      IL_0006:  ldloc.0
      IL_0007:  callvirt   instance string [UsingTest]UsingTest.DisposableClass::WhoIsIt()
      IL_000c:  pop
      IL_000d:  leave.s    IL_0027
    }  // end .try
    catch [System.Runtime]System.Exception
    {
      IL_000f:  stloc.1
      IL_0010:  ldstr      "INNER: "
      IL_0015:  ldloc.1
      IL_0016:  callvirt   instance string [System.Runtime]System.Exception::get_Message()
      IL_001b:  call       string [System.Runtime]System.String::Concat(string,
                                                                        string)
      IL_0020:  call       void [Microsoft.VisualStudio.TestPlatform.TestFramework]Microsoft.VisualStudio.TestTools.UnitTesting.Assert::Fail(string)
      IL_0025:  leave.s    IL_0027
    }  // end handler
    IL_0027:  leave.s    IL_0033
  }  // end .try
  finally
  {
    IL_0029:  ldloc.0
    IL_002a:  brfalse.s  IL_0032
    IL_002c:  ldloc.0
    IL_002d:  callvirt   instance void [System.Runtime]System.IDisposable::Dispose()
    IL_0032:  endfinally
  }  // end handler
  IL_0033:  leave.s    IL_004d
}  // end .try
catch [System.Runtime]System.Exception
{
  IL_0035:  stloc.2
  IL_0036:  ldstr      "OUTER: "
  IL_003b:  ldloc.2
  IL_003c:  callvirt   instance string [System.Runtime]System.Exception::get_Message()
  IL_0041:  call       string [System.Runtime]System.String::Concat(string,
                                                                    string)
  IL_0046:  call       void [Microsoft.VisualStudio.TestPlatform.TestFramework]Microsoft.VisualStudio.TestTools.UnitTesting.Assert::Fail(string)
  IL_004b:  leave.s    IL_004d
}  // end handler

.try
{
  .try
  {
    IL_0002:  newobj     instance void [UsingTest]UsingTest.DisposableClass::.ctor()
    IL_0007:  stloc.0
    IL_0008:  ldloc.0
    IL_0009:  callvirt   instance string [UsingTest]UsingTest.DisposableClass::WhoIsIt()
    IL_000e:  pop
    IL_000f:  leave.s    IL_0033
  }  // end .try
  catch [System.Runtime]System.Exception
  {
    IL_0011:  stloc.1
    IL_0012:  ldstr      "ONLY: "
    IL_0017:  ldloc.1
    IL_0018:  callvirt   instance string [System.Runtime]System.Exception::get_Message()
    IL_001d:  call       string [System.Runtime]System.String::Concat(string,
                                                                      string)
    IL_0022:  call       void [Microsoft.VisualStudio.TestPlatform.TestFramework]Microsoft.VisualStudio.TestTools.UnitTesting.Assert::Fail(string)
    IL_0027:  leave.s    IL_0033
  }  // end handler
}  // end .try
finally
{
  IL_0029:  ldloc.0
  IL_002a:  brfalse.s  IL_0032
  IL_002c:  ldloc.0
  IL_002d:  call       instance void [UsingTest]UsingTest.DisposableClass::Dispose()
  IL_0032:  endfinally
}  // end handler

MSBassSinger wrote:

That comes across as more religion than a rational approach.

MSBassSinger wrote:

The unit test for the "using" statement took 28 ms, while the standard use took 18 ms.

public void StandardUsageTest()
{
    try
    {
        DisposableClass test = null;
        try
        {
            test = new();
            try
            {
                String result = test.WhoIsIt();
            }
            catch (Exception ex)
            {
                Assert.Fail($"INNER: {ex.Message}");
            }
        }
        finally
        {
            test?.Dispose();
        }
    }
    catch (Exception exOuter)
    {
        Assert.Fail($"OUTER: {exOuter.Message}");
    }
}