Think with Enlab

Diving deep into the ocean of technology

Stay Connected. No spam!

How to Inspect and Improve Memory Usage With dotMemory

 

In .NET programming, if we don't code the right way, like using static variables, disposable objects, events, and threads, memory leaks can happen. When your app references an object that no longer needs to perform the desired task, it can make the garbage collector unable to reclaim the memory used, resulting in its performance degradation. In this article, I'd like to share with you a powerful tool to detect and resolve memory leak issues - that is dotMemory.

 

How to Find Memory Leak Using dotMemory

First, what is a memory leak? According to pcmag.com, it is “a condition caused by a program that does not free up the extra memory it allocates.” And jetbrains.com says, “A memory leak is a result of incorrect memory management when an object is stored in memory but cannot be accessed by the running code." Also, “memory leaks add up over time, and if they are not cleaned up, the system eventually runs out of memory.”

General steps to detect and analyze memory leak issues using dotMemory:

 

Step 1. Run the dotMemory application and config to run your application.

Step 1. Run dotMemory application and config to run your application

 

In my example, I am configuring to run a console application from the local.

 

configuring to run a console application from local


Step 2. Get snapshots.

  • Get a snapshot after starting your application with dotMemory.

Get a snapshot after starting your application with dotMemory

  • Then, write some bad code like instantiating a disposable object outside of the using scope (to stimulate your application to cause a memory leak).
  • Get snapshot again.

step 2 Get snapshot after trying with bad code

  • Now, we have two snapshots before and after running a feature in your application.

 

Step 3. Compare snapshots
You can take more snapshots when monitoring the application. After that, select two snapshots that you want to compare and click on the compare button.

select two snapshots that you want to compare and click on the compare button


Step 4. Analyze the snapshots
In analysis windows, select the filter “Namespace”:

In analysis windows, select the filter “Namespace”
Then, you can see in the following window these elements:

  • The number of new objects
  • Surviving objects
  • The memory size of objects
    etc.

All is by “namespace” while your application is running.

see in the following window these elements - The numbers of new objects - Surviving objects Memory - Size of objects

 

Typical Memory Leak Situations

Subscribe and Unsubscribe Events

Event handling in .NET is a popular cause of memory leaks. The reason is that once you subscribe to an event, memory is allocated, and it’s only released when you explicitly unsubscribe it. See the example below:

Event handling in .NET - a popular cause of memory leaks

 

After running and closing the above console app with dotMemory, you will see this:

result after running and closing the above console app with dotMemory

The ThresholdReached event is referenced in memory and can not be released after closing the application. To solve this problem, add a code to unsubscribe from the event.

The ThresholdReached event is referenced in memory and can not be released after closing the application

 

Next, run dotMemory again, and you no longer see the ThresholdReached.

ThresholdReached is gone

 

Cache Big Data
Like the static variable, in some cases, we may catch data in memory, but the application may run out of memory when caching big data. For example:

public static IDictionary<int, string> CacheData = new Dictionary<int, string>();
{
        public string GetData(int id)
        {
            if (!CacheData.ContainsKey(id))
            {
                var result = GetDataFromDatabase(id);
                CacheData.Add(id, result);
            }

            return CacheData[id];
        }

        private string GetDataFromDatabase(int id)
        {
            return "Text";
        }
}

 

In this case, the method GetDataFromDatabase is expensive to call, so I cache the data returned to a static variable. After a while, the memory will be eaten up and may cause the application to crash. The solution can be to catch data to a caching server like Redis.

 

Forget to Dispose of Unmanaged Memory

The garbage collector (GC) handles managed memory cleanup, but it doesn’t cover unmanaged memory like a database connection or file streams.

For example, your application creates a new connection to the database. After connecting and getting the data, you forget to close the connection. The GC doesn't manage the unmanaged memory allocated for that connection, so it is left there as a memory leak.

The same issue can help with using file streams. See the below example:

I add code to read a text file by stream reader and forget to close it.

add code to read a text file by stream reader and forget to close it

After reading the file, I get a snapshot from dotMemory as follows:

get a snapshot from dotMemory

 

In the Snapshot windows and Finalizable section, it shows the File Stream that I need to close.

in Snapshot windows and Finalizable section, it shows the File Stream that needs closing


Open the FileStream object and see the details:

Open FileStream object and see the details


If I add the using statement like the one below, the issue is gone.

add the using statement, the issue is gone


In dotMemory, the stream reader no longer shows.

In dotMemory, the stream reader no longer shows

 

Using Disposable Objects

In class Counter, I have a method to get the total number of users from the database, so I need a database connection object which is disposable, so I have to implement an IDisposable interface in order to clean it up at the end.

public static IDictionary<int, string> CacheData = new Dictionary<int, string>();
{
        public string GetData(int id)
        {
            if (!CacheData.ContainsKey(id))
            {
                var result = GetDataFromDatabase(id);
                CacheData.Add(id, result);
            }

            return CacheData[id];
        }

        private string GetDataFromDatabase(int id)
        {
            return "Text";
        }
}

 

Final thoughts

dotMemory is a great tool for investigating and optimizing memory usage in applications. That is why I often use it in almost every application I’ve developed so far. I hope the above sample cases will be helpful to you, and check out this resource to learn more about dotMemory.

 

CTA Enlab Software

 

References

About the author

Vu Dao

I'm working as a Senior Developer at Enlab Software. I'm passionate about technology and aiming to advance my skill in .NET back-end coding. Outside work, I'd turn into a semi-pro photographer and capture moments in life with my camera. I hope to share more tech talk and foster meaningful conversations about .NET in the future.

Up Next

Big Data Technologies Transforming Software Development
July 05, 2024 by Dat Le
In the rapidly evolving world of software development, Big Data stands out as a transformative force....
June 27, 2024 by Dat Le
In today's rapidly evolving digital landscape, secure coding practices are paramount to safeguarding applications from a...
June 20, 2024 by Dat Le
In the rapidly evolving digital landscape, the role of User Interface (UI) and User Experience (UX)...
Leveraging UX Design Principles in Software Development
June 17, 2024 by Dat Le
In the dynamic world of software development, one element has emerged as crucial to success: User...
Roll to Top

Can we send you our next blog posts? Only the best stuffs.

Subscribe