Styjun

I am playing around with IDisposable interface and GC and there is something which i cannot understand.

So we have the following class:

public class DatabaseState : IDisposable

 protected SqlConnection _connection;

 public virtual string GetDate()
 
 if (_disposed)
 throw new ObjectDisposedException("DatabaseState");

 if (_connection == null)
 
 var connectionString = ConfigurationManager.ConnectionStrings["master"];
 _connection = new SqlConnection(connectionString.ConnectionString);
 _connection.Open();
 
 using (var command = _connection.CreateCommand())
 
 command.CommandText = "SELECT getdate()";
 return command.ExecuteScalar().ToString();
 
 

 private bool _disposed;

 public void Dispose()
 
 Dispose(true);
 GC.SuppressFinalize(this);
 

 protected virtual void Dispose(bool disposing)
 
 if (_disposed)
 return;

 if (disposing)
 
 if (_connection != null)
 
 _connection.Dispose();
 _connection = null;
 
 _disposed = true;
 
 

As you can see the class is pretty simple (it only gets current date).

In the Main i have the following code:

class Program

 static void Main(string[] args)
 
 Console.WriteLine("'g' to Get Date; 'gc' to Garbage Collect; 'x' to Exit");
 var command = "";
 while (command != "x")
 
 command = Console.ReadLine();
 switch (command)
 
 case "g":
 GetDate();
 break;

 case "gc":
 GC.Collect();
 break;
 
 
 

 private static void GetDate()
 
 using (var databaseState = new DatabaseState())
 //var databaseState = new DatabaseState();
 
 Console.WriteLine(databaseState.GetDate());
 
 

The first experiment is when i use IDisposable with using (I have used VS build in Diagnostic Tools.)

Look at the following snapshots:

The number represent snapshot ID.

1. When I started application. As you can see we have allocated only 29.38 KB.


2. When I entered "g" we have allocated 245.70KB which is normal. We have opened a connection, handshake and etc.


3. When I entered "g" for the second time we have allocated only 0.55 KB which also should be normal. I checked what kind of object type we have created: Hashtable, Microsoft.Win32.SafeHandles.SafeFileMappingHandle,SectionRecord and etc. I am not familiar with these object types and I think that there are related somehow with CLR.

From now on the strange things happened for me.

4, 5,6,7 I did the same i pressed "g". As you can see we haven't allocated any memory. And this is my first question Why?.

8. I pressed "gc" which force GC.Collect(). At that point i was surprised. We haven't released any memory. As I know GC.Collect() released the memory from all generations. The second question Why GC hasn't released any memory at this point ?




9. I pressed "g" again. The same thing as in snapshots 4, 5, 6 and 7. We haven't allocated any memory. Why?

10, 11 Randomly created snapshots.

12. This is also something interesting. I haven't done any actions and something has allocated 2.4 KB memory. Again i checked what kind of object types we have created: ContextCallback, Microsoft.Win32.SafeHandles.SafeFileMappingHandle, AppDomainPauseManager, ThreadPoolWorkQueue. And again I am not familiar with these types but I think that there are related to CLR.




13. The same as 12. I haven't done any actions for a while but this time we released 20.66 KB memory. Why?

To summarize:

By my understanding the IDisposable and GC should work in a little different way.
The first time when I instantiate DatabaseState I should open connection, handshake and etc. Because of that we will allocate more memory.
Because of the fact that we use DatabaseState instance in using statement we will release these unmanaged resources. The next time when I use instance of DatabaseState I should allocate some memory (but as I saw from the snapshots 4,5,6,7 and 9 I didn't allocate any memory) only for the instance because the connection, handshake has already been done.

I am missing something but i don't know what and where.

Regards