Why can we still use a disposed object?

Question

I have DisposedPatterenDemo class inherit from IDisposable. I have Disposed the object of this class and then after it tries to call the Method() of the same class, I am getting returned value from Method but obj is already disposed of. var res=obj.Method(); not failing ? Why it is not getting failed?

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

                DisposedPatterenDemo obj = new DisposedPatterenDemo();
                obj.Initialize();
                obj.Dispose();
                var res=obj.Method(); //Here it return value
    }
    }


 class DisposedPatterenDemo:IDisposable
    {
        private bool Disposed = false;
        StreamReader str = null;
        PaymentStub obj = new PaymentStub();

        public void Initialize()
        {
            str = new StreamReader(@"C:\Test\abc.pdf");
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);

        }
        public string Method()
        {
            var abc = "New";
            return abc;
        }
        public void Dispose(bool disposing)
        {
            if (!Disposed)
            {
                if (disposing)
                {
                    Console.WriteLine("Called From Dispose");
                    if(str!=null)
                    {
                        str.Dispose();
                    }
                }
                else
                {
                    //Clear all the unmanaged resources here  
                }
                Disposed = true;
            }
        }
    }

Because `Method()` doesn't contain code like `if (Disposed) throw new ObjectDisposedException();`. This doesn't get done for you automatically. — Matthew Watson, Feb 20 '20 at 09:31

score 1 · Accepted Answer · answered Feb 20 '20 at 09:32

1

Disposing only means that Unmanaged resources used by the object would be disposed off. It does not mean that the object would be cleared off memory. This means that methods of that object, which does not depend on any unamanaged resources could still be called without problem.

To prevent this, As @Matthew suggested, you need to keep an instance variable that tells whether the current instance was disposed or not, and handle it accordingly in the method.

answered Feb 20 '20 at 09:32

Prakhar Londhe

1,431
1
12
26

Means, I can say that Idispoable is just a pattern, not the technique to clear the object of class on which it is implemented. Is it the case? – Sukhraj Feb 20 '20 at 10:13
Yes, I disposable is pattern which you can implement to clear *unamanaged resources* (like Database connections) of your object immediately. The object is cleared only when it goes out of scope and doesn't have any reference, so that garbage collector collects it. – Prakhar Londhe Feb 20 '20 at 10:15
For more information refer here https://stackoverflow.com/questions/1987251/manually-destroy-c-sharp-objects – Prakhar Londhe Feb 20 '20 at 10:17
thank you. I have one more doubt, what is the role of GC.SuppressFinalize(this) if the object will get clear when it goes out of scope, why we need to inform GC? – Sukhraj Feb 20 '20 at 10:35
GC.SuppressFinalize() would tell the garbage collector not to call the Object.Finalize method, which releases the unmanaged resources, because we have already did so using the IDisposable pattern. – Prakhar Londhe Feb 20 '20 at 10:41

Why can we still use a disposed object?

1 Answers1