Introduction to C# Memory Leak

A Memory Leak is a situation that occurs when a program or an application uses the system’s primary memory over a long period. When the program does not release the memory occupied by it during execution, even after it completes its execution process, then this allocated memory space degrades the system’s performance and can make it unresponsive. In this topic, we are going to learn about C# Memory Leak.

It is the responsibility of a garbage collector to free the unused allocated memory, but we still encounter the problem of memory leak because we sometimes refer the unused object from a variable that never goes out of scope throughout the application’s lifetime.

Syntax

There are many ways to avoid memory leak in C#; we can avoid memory leak while working with unmanaged resources with the help of the ‘using’ statement, which internally calls Dispose() method. The syntax for the ‘using’ statement is as follows:

using(var  objectName = new AnyDisposableType)
{
//user code
}

In the above statements, ‘var’ is the keyword which is used to store any type of data, and the compiler can figure out this data type at compilation time. ‘objectName’ is any user-defined name for the object. ‘new’ is the keyword used to initialize object and ‘AnyDisposableType’ can be any class like StreamReader, BinaryReader, SqlConnection, etc. whose object can be disposed of with the help of ‘using’ statement.

How Does Memory Leak Work in C#?

For .NET applications, we have a garbage collector to dispose of the unused memory, but still, we encounter the problem of memory leaks. This does not mean that the garbage collector does not work properly, but this occurs because of some ignorance by the programmer.

Suppose we ignore memory leaks in our application for a very long period. In that case, we increase our application’s memory consumption, which degrades the performance of our application and can gradually destroy it, giving the OutOfMemoryException.

There are two major causes for memory leak in C#:

• The first cause is having an unused object that is no longer required but still referenced by a variable that has its scope throughout the application’s lifetime. Since this object has a reference, it will not be destroyed by the garbage collector and will remain in the memory forever and can become a reason for a memory leak. An example of this situation can be an event that we have registered but is never unregistered.
• The second cause is allocating the memory for unmanaged resources and then not releasing it after use. Like managed resources, the unmanaged resources cannot be garbage collected automatically. Thus, it is the responsibility of the programmer to release that memory after use.

Some reasons causing memory leak in C# are as follows:

• When we subscribe to an event, the class publishing the event holds a reference to the class subscribing to it. Due to this, the garbage collector will not dispose of the object of the class who subscribed to the event, and at the same time, if the programmer does not unsubscribe that event, then it will result in a memory leak.
• Capturing a class member in an anonymous method can result in a memory leak.
• Static classes and their associated static variables and anything referenced by these static variables can never be garbage collected and can lead to a memory leak.
• Using caching functionality for an indefinite period can cause a memory leak.
• If we have an infinitely running thread that has no task in our application but references to objects, this can lead to a memory leak.
• The garbage collector does not manage the unmanaged resources. Thus, not disposing of the unmanaged resources after using it can lead to a memory leak.

Examples of C# Memory Leak

Different examples are mentioned below:

Example #1

This example shows a thread waiting for itself to terminate and thus can become a cause of memory leak.

Code:

using System;
using System.Threading;
namespace ConsoleApp4
{
public class Program
{
public static void Main()
{
while (true)
{
Console.WriteLine("Press enter key to start new thread");
Console.ReadLine();
Thread thread = new Thread(new ThreadStart(StartThread));
thread.Start();
}
}
public static void StartThread()
{
Console.WriteLine("Thread " +
Thread.CurrentThread.ManagedThreadId + " started");
//Wait until current thread terminates
Thread.CurrentThread.Join();
}
}
}

Output:

Whenever we press ‘Enter’ in the above program, its memory utilization increases.

Example #2

Example showing the use of unmanaged resources with the help of ‘using’ statement to avoid a memory leak.

Code:

using System;
using System.IO;
namespace ConsoleApp4
{
public class Program
{
public static void Main()
{
string filePath = @"E:\Content\memoryLeak.txt";
string content = string.Empty;
try
{
//writing file using StreamWriter
//making use of 'using' statement to dispose object after using it
using (StreamWriter writer = new StreamWriter(filePath))
{
writer.WriteLine("Learning C# programming");
}
//reading file using StreamReader
using (StreamReader streamReader = new StreamReader(filePath))
{
content = streamReader.ReadToEnd();
}
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
Console.ReadLine();
}
Console.WriteLine(content);
Console.ReadLine();
}
}
}

Output:

How to avoid OutOfMemoryException in C#?

Some points to keep in mind to avoid OutOfMemoryException due to memory leak in C# are as follows:

• If we have subscribed to an event, we need to unregister the event handler from the event. We can do this by implementing IDisposable.
• Capturing the local variable instead of the class variable in the anonymous method can avoid a memory leak.
• Avoiding excessive use of static variables in our application, especially when these variables are of reference types, we can avoid the situation of memory leak.
• If we have caching functionality in our application, then we need to clear the cache regularly, especially if it is of no use for a long period. We can also limit caching size and can make use of WeakReference to store cached objects.
• Proper management of threads in applications avoids memory leaks.

Conclusion

When an application doesn’t release the memory that it has used during its execution, this memory will be blocked and cannot be used by any other process, resulting in a memory leak. The garbage collector can automatically dispose of managed objects but cannot dispose of unmanaged objects or resources.

Recommended Articles

This is a guide to C# Memory Leak. Here, we discuss how Memory Leak works in C# and Examples and the codes and outputs. You may also have a look at the following articles to learn more –

1. C# LinkedList
2. Type Casting in C#
3. C# Data Grid View
4. IEnumerable C#

The post C# Memory Leak appeared first on EDUCBA.