IDisposable interface – LearnC#WithDarko

Finalize method or Destructor

Finalize method or Destructor are synonyms. We create destructor by typing ~ (tilde sign) and class name. Use of destructor is to cleanup unamaged resources when Garbage collector runs. It is a good practice that your destructor calls Dispose method and provides it with false boolean value. Why with false value? Because First Dispose method is called by your code and provides second Dispose method with true value, meaning only managed code will be disposed of, and by providing Dispose of method with false method we ensure that garbage collector will not try to destroy of already disposed of objects.

Destructor can be called in two ways:

When Garbage collector runs by itself
When we invoke Garbage Collector by using GC.Collect()

Implementing IDisposable

06/09/2016 / Darko / 0 Comments

As we saw in previous post, we can use using statement to automatically dispose of objects. To use using directive our class needs to implement IDisposable interface. To correctly implement IDisposable interface we should stick to some guidelines. Following example will show you the correct way to implement it.

Example of Implementing IDisposable interface to a class

We will start by creating FileRead class whose job is to create file and write line to it. FileRead class will implement IDispose interface and two Dispose methods. General rule is that you should create two Dispose methods:

public void method with no parameters
protected void method with a boolean input parameter

Job of public Dispose method is to call second Dispose method where objects are really disposed of, and second job is to notify Garbage collector that this instance of class is cleaned up and that there is no need to check-up upon it during garbage collection.

using System;
using System.IO;

namespace SimpleIDisposableImplementation
{
    class Program
    {
        static void Main(string[] args)
        {
            // Application starts here and calls
            // FileRead class that implements IDisposable interface.
            // We supply FileRead constructor with location of our txt file
            using (FileRead read = new FileRead(@"d:\test.txt"))
            {
                // FileRead.Dispose method is called after exiting using statement
            }
        }
    }

    public class FileRead : IDisposable
    {
        private FileInfo _fileInfoInstance;
        private StreamWriter _streamWriter;

        private bool disposed;

        public FileRead(string filePath)
        {
            _fileInfoInstance = new FileInfo(filePath);
            CreateFileAndWriteToIt();
        }

        private void CreateFileAndWriteToIt()
        {
            _streamWriter = _fileInfoInstance.CreateText();
            //_fileInfoInstance.Exists property tells us
            // if file exists by returning boolean value
            if (_fileInfoInstance.Exists)
            {
                _streamWriter.WriteLine("Hello World");
            }
        }

        public void Dispose()
        {
            // We call our protected virtual Dispose method
            // and do real cleanup there
            Dispose(true);

            // Garbage collector is notified 
            // that we have cleaned this instance 
            // is cleaned and needs not to be finalized
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool indDisposing)
        {
            //First we check if object is Disposed of
            if (disposed == true)
                return;

            if (indDisposing == true)
            {
                // Then we check for state of object
                // No need to dispose of if
                // instance is null
                if (_streamWriter != null)
                {
                    // We dispose of object
                    _streamWriter.Dispose();
                    // And to be shure we
                    // set it to null
                    _streamWriter = null;
                }

                // Lastly we set disposed field to true
                // to set a flag that object is disposed of
                disposed = true;
            }
        }
    }
}

using System;

using System.IO;

namespace SimpleIDisposableImplementation

{

class Program

{

static void Main(string[] args)

{

// Application starts here and calls

// FileRead class that implements IDisposable interface.

// We supply FileRead constructor with location of our txt file

using (FileRead read = new FileRead(@"d:\test.txt"))

{

// FileRead.Dispose method is called after exiting using statement

}

public class FileRead : IDisposable

{

private FileInfo _fileInfoInstance;

private StreamWriter _streamWriter;

private bool disposed;

public FileRead(string filePath)

{

_fileInfoInstance = new FileInfo(filePath);

CreateFileAndWriteToIt();

}

private void CreateFileAndWriteToIt()

{

_streamWriter = _fileInfoInstance.CreateText();

//_fileInfoInstance.Exists property tells us

// if file exists by returning boolean value

if (_fileInfoInstance.Exists)

{

_streamWriter.WriteLine("Hello World");

}

public void Dispose()

{

// We call our protected virtual Dispose method

// and do real cleanup there

Dispose(true);

// Garbage collector is notified

// that we have cleaned this instance

// is cleaned and needs not to be finalized

GC.SuppressFinalize(this);

}

protected virtual void Dispose(bool indDisposing)

{

//First we check if object is Disposed of

if (disposed == true)

return;

if (indDisposing == true)

{

// Then we check for state of object

// No need to dispose of if

// instance is null

if (_streamWriter != null)

{

// We dispose of object

_streamWriter.Dispose();

// And to be shure we

// set it to null

_streamWriter = null;

}

// Lastly we set disposed field to true

// to set a flag that object is disposed of

disposed = true;

}

More examples of IDisposable coming up soon.

Garbage Collector

05/09/2016 / Darko / 0 Comments

Have you ever wondered how applications know how much memory to use, how is that memory distributed or who cleans up memory? All those operations are executed by the Garbage Collector.

What triggers Garbage collector?

Your system is low on physical memory. Meaning your system has used up almost all of your RAM memory and will start to use page file.
The memory that is used by allocated objects on the managed heap surpasses an acceptable threshold. This threshold is continuously adjusted as the process runs.
Application is written to call the GC.Collect method.

Using keyword

30/08/2016 / Darko / 0 Comments

Before we continue to FileInfo and Streams we need to explain using keyword in details.

Using directive

Using directive shortens our syntax so that we do not always have to type entire namespace:

// Without adding using directive to top of namespace
using System.Collections.Generic;
// We could create new list like this:
System.Collections.Generic.List<string> newList = new System.Collections.Generic.List<string>();
// No penalties or errors will occur if we instantiate our List  like that even if we use using directive.

// Without adding using directive to top of namespace

using System.Collections.Generic;

// We could create new list like this:

System.Collections.Generic.List<string> newList = new System.Collections.Generic.List<string>();

// No penalties or errors will occur if we instantiate our List like that even if we use using directive.

Using directive grants us access to static members having to qualify the access with the type name:

// Adding this using directive allows us to access Console class
using System;
// Console class is static class

// Adding this using directive allows us to access Console class

using System;

// Console class is static class

Using directive enables us to create alias directive.

using ListUsing = System.Collections.Generic;
ListUsing.List<string> newList = new ListUsing.List<string>();

1 2	using ListUsing = System.Collections.Generic; ListUsing.List<string> newList = new ListUsing.List<string>();

Using statement

Using statement provides us with a easy to use syntax which in return guarantees us with that types that implement IDisposable interface will be disposed of when we finish with them. For now do not stress yourself with questions like why do I need to dispose of something and what use IDisposable interface is to me. Those questions will be covered in a future post.

Example of using statement

Usage of using statement is straight-forward.

First we type using keyword and open parentheses, and inside of those brackets we instantiate class that implements IDisposable interface. After that we proceed to use class instance inside curly brackets.

using (ClassThatImplementsIDisposable myClass = new ClassThatImplementsIDisposable ())
{
  myClass.MethodInsideMyClass();
}

using (ClassThatImplementsIDisposable myClass = new ClassThatImplementsIDisposable ())

{

myClass.MethodInsideMyClass();

}

Of-course you can instantiate more than one class while using using directive, just remember to separate them with coma:

using (ClassThatImplementsIDisposable myClass = new ClassThatImplementsIDisposable(),
       SecondClassThatImplementsIDisposable mySecondClass = new SecondClassThatImplementsIDisposable().)
{
  myClass.Method();
  mySecondClass.Metod5);
}

using (ClassThatImplementsIDisposable myClass = new ClassThatImplementsIDisposable(),

SecondClassThatImplementsIDisposable mySecondClass = new SecondClassThatImplementsIDisposable().)

{

myClass.Method();

mySecondClass.Metod5);

}

I hope you will find using keyword helpful. I certainly use it on a daily basis in both forms

Language

Recent Posts

Archives

Categories

TagIDisposable interface