How can I do an action when a variable goes out of scope?

Question

EDIT: So it looks like the only way to do this is with IDisposable. I suspected as much but it's still a bit of a bummer. I may make a class for this that takes an Action as @mjwills suggests but I still personally wish there was a way to do this without the using block. Alternative syntax like "using (var foo = new Bar([action]);" that makes the using statement apply to the block it's called from would be great.

In C# is it possible to perform an action when a variable goes out of scope? In C++ I would use an object's destructor to do something when it goes out of scope, but the garbage collector means I can't (cleanly) get the same behavior in C#. This is what I would write in C++:

class SetOnDestruction
{
    bool& m_thingToSet;
    bool m_newValueForThing;

public:
    SetOnDestruction(bool& thingToSet, bool newValueForThing)
        : m_thingToSet(thingToSet)
        , m_newValueForThing(newValueForThing)
    {

    }

    ~SetOnDestruction()
    {
        m_thingToSet = m_newValueForThing;
    }
};

void ExampleUsage()
{
    bool thingToSet = true;
    {
        SetOnDestruction setter(thingToSet, false);
        // do some stuff here
    }
    // thingToSet should now be false
}

I don't want to use IDisposable because then I'm wrapping my functions in big using blocks for what is really just a bit of syntactic sugar.

Does anyone know of anything relevant?

Answer 1

If you're trying to destroy unmanaged resources we can in fact use a destructor such as

~SetOnDestruction()
{
  /* destruction things */
}

However, this gets called when the garbage collector destroys the object and thus is non-deterministic.

The only other way is using IDisposable More info on IDisposable from MSDN here

Edit: In honor of the down votes (And pure interest) Let's see not if we should do this but if we can do this

We could hypothetically enforce local scope by calling something like this

    class Program
    {
        static void Main(string[] args)
        {
            LocalScopeWrapper();
        }

        private static void LocalScopeWrapper() // maybe I could have a better name?
        {
            var testObj = new TestObj();
            testObj.Print();
            Console.WriteLine($"Total memory used before forced collect {GC.GetTotalMemory(false)}");
            testObj = null;
            GC.Collect(0); // Generation 0, lets only clear the smallest Small Object Heap
            Console.WriteLine($"Total memory used after forced collect {GC.GetTotalMemory(true)}");
        }

        private class TestObj
        {
            public void Print()
            {
                Console.WriteLine("HelloWorld");
            }
        }
    }

Here we're forcing the object to be collected after we set it to null. Makes sense, but not exactly what we want, and as Dire Whale asked for not clean.

But, I wanted to see if we emulate C++ behavior, and it is possible.

We could use Pinvoke and handles to pass our object to C/C++ libraries and call free as shown in this great answer by @xanatos

I was curious how bad we could get in C#, and this seemed like the ultimate of getting around the GC by letting a Pinvoke delete things under our nose. It isn't useful but interesting none the less.