Is this 100% thread safe way of making sure base.Release is only ever *ever* called once?

multithreadeddisposal.cs

private Object instance;

public override void Dispose()
{
	var localInstance = instance;
	if (localInstance == null)
	{
		return;
	}
	// we're trying to atomically replace the instance with null.
	var originalValue = Interlocked.CompareExchange(ref instance, null, localInstance);
	if (originalValue == null)
	{
		// some other thread was quicker.
		return;
	}
	// ok, do regardless of other threads, it looks like I'm the one to have nullified the instance.
	// it is my responsibility to finish the job while all other threads go home.
	base.Release(originalValue);
}

yes it's thread safe. it can be much simpler with this tho:

        var original = Interlocked.Exchange(ref instance, null);
        if (original != null)
        {
            base.Release(original);
        }

thanks bling,

I'm doing the additional check at the beginning to save a few cycles. You're probably right though that several nanoseconds are not worth the additional clutter.