Detecting and Preventing Memory Leaks in .NET

For a prolonged period, it has always been a nightmare for software developers to deal with memory leaks in the system. When it comes to production servers, they are supposed to be able to operate with the minimum downtime possible. Memory leaks can broadly impact the performance of .NET applications and can be the most annoying part of coding .NET developers face.

Memory leaks can slow down the processing performed by the server by eating large chunks of memory. This can have a bad impact on the experience of the end-user, as they may need to restart their computer to get it operational again.

With that in mind, this .NET programming tutorial will discuss what memory leaks are, how they occur, the various forms of memory leaks, what causes memory leaks, and the strategies programmers use to detect and prevent memory leaks.

Read: Productivity Tools for .NET Developers

What Are Memory Leaks?

Memory leakage happens when an application or program holds a computer’s primary memory for a prolonged time. You can think of it as when any program does not return the allocated memory space after finishing its task. When this happens, the system may become unresponsive, stuck, and unable to perform subsequent tasks. The memory leakage can be detected or prevented by GC (Garbage Collection) or other automation tools.

What are the Types of Memory Leaks in .NET?

There are different ways that memory leakage happens in a .NET application. Some of the forms of memory leaks in .NET apps include:

• Inadequate knowledge of how the garbage collector works in the .NET application runtime
• Objects are not destroyed once they become useless
• Allocation of unmanaged code
• Allocation of unmanaged resources like socket, files, etc.
• Bugs in code may also contribute to memory leakage

What Causes Memory Leaks in Programs?

Most programmers probably wonder how there can be a leakage in memory in their programs if the garbage collector is there to ensure that everything is collected. There may be two root causes for memory leaks to occur. They are:

• • The first reason might be due to a developer referencing objects that are not used. The memory allocated for such objects cannot be collected because they are being referenced. They may remain in memory for an infinite period of time. For example, if you have registered for an event but forget to unregister it.
  • The second reason is when you allocate unmanaged memory and forget to deallocate it. Unmanaged memory is a memory that the garbage collector is not used for allocation and deallocation. .NET has lots of classes for allocating unmanaged memory. Any operation you perform that involves tasks related to graphics, network calls, file systems, or data streaming all consume unmanaged memory behind the scenes. These classes do have a dispose method which is used to deallocate the unmanaged memory. If the programmer skips calling dispose once his task finishes, the memory may remain unallocated infinitely.

Read: Best C# and .NET IDEs

How to Detect Memory Leaks in .NET

Below are a few methods developers can use to detect memory leaks in their applications.

Using a Memory Profiler

Memory Profilers are a tool for locating and repairing memory leaks. Although the strategy seems to be a little bit expensive, it is worth getting familiar with at least one memory profiler.

There are some well-known memory profiler tools like DotMemory, ANTS Memory profiler, and SciTech. If you have Visual Studio Enterprise edition installed on your computer, you can take advantage of the free memory profiler tools that come with the enterprise edition of Visual Studio.

All memory profilers work in the same way. By using a profiler tool, you have the option of opening a dump file or attaching it to an active process. Profilers create a snapshot of your process’ current memory heap. Note that a ‘snapshot’ provides the information about all the classes, instances of classes, and call stacks of the instances. After creating a snapshot you can see how many instances are allocated and how much memory is being consumed and what the GC Root reference path is.

But how does a memory profiler tool work? The memory profiler takes two snapshots. One snapshot is taken before the operation and the other one is taken after the operation. Now, these two snapshots are compared and checked to see if the memory is returned to the same state. Comparing the snapshots is the most effective and useful profiling technique.

Making Object ID Find Memory Leakage

Assume you suspect that, after performing an action, a particular class might be causing memory leakage. To make sure that the resource (class in our case) is collected by the garbage collector, follow this procedure:

• • • Set a breakpoint where the instance of the class is created.
    • Hover over the variable, right-click and select Make Object ID.
    • Check the scenario where you are supposed to dereference your instance.
    • Force the garbage collector to run by using the following commands:

gc.Collect();
gc.WaitForPendingFinalizers();
gc.Collect();

• • • Check if there is still leaking memory. Type $1 in the immediate window. If the value returned is null, the resource is collected by the garbage collector – otherwise, you may still have memory leakage.

Read: Project Management Software Tools for .NET Developers

Using Diagnostic Tool

The Diagnostic Tool window is really helpful. It can easily identify these issues: garbage collection pressure and memory leaks.

Sometimes it can be impossible to identify if there is any memory leaks. Especially in the case of GC pressure – a scenario in which you create an object and dispose of it so quickly that the garbage collector is not able to locate it. In such cases, a developer may not be able to identify memory leaks, but you will be able to detect the presence of memory leakage, and knowing the presence of memory leakage is useful in itself. If you have Visual Studio Enterprise edition, it has a diagnostic window in which there is a memory profiler tool that can help you to locate the memory leak.

Tools for Preventing Memory Leaks in .NET

In this section, we will discuss the developer tools used for preventing memory leaks.

.NET Memory Profiler

.NET Memory Profiler is a useful tool that is used for checking memory leaks and memory optimization in .NET. The tool allows programmers to retrieve all of the information regarding instances allocated and residing on the garbage collection heap. The tool provides information in real-time, both in a graphical form and numerical form. Let’s take a look at some of the main features you get with the .NET profiler tool:

• • • • • Tracking of unmanaged resources
        • Automatic memory analysis
        • Integration with different Visual Studio editions
        • Collecting snapshots of the heap
        • Can be attached to a running .NET process easily

GDIUsage

GDIUsage is a free tool. The tool focuses on GDI (Graphics Device Interface) objects. With this tool, you can take a snapshot of the GDI objects and perform an action that you think might be responsible for memory leaks, and then take another snapshot after performing the action. If you compare the difference between the previous resource usage and the one that is taken after performing action it may help you to easily find which GDI objects have been allotted and which are released.

Furthermore, the tool features a graphical display of GDI objects. This helps you to identify what bitmap is leaked and so it becomes easier to identify the reason for the leakage.

dotTrace

dotTrace is a memory and performance profiler from JetBrains. This tool is used for performance monitoring for ASP.NET applications. Some of the features of dotTrace include:

• • • • • Memory profiling
        • Command Line Interface
        • Snapshot exploring, and support for multiple snapshots
        • Profiling API
        • Easy Integration with Visual Studio

Final Thoughts on Memory Leaks in .NET

Being able to build and develop fast-paced applications means it is crucial to know how memory leaks can impact the performance of software applications. As such, it is important for developers to learn the skills to effectively utilize available memory resources and to get familiar with tools and techniques that can be used to prevent the system from leaking memory.

Read more .NET programming and software development tutorials.