Memory leak in CS

A memory leak, in computer science (or leakage, in this context), occurs when a computer program consumes memory but is unable to release it back to the operating system. In object-oriented programming, a memory leak may happen when an object is stored in memory but cannot be accessed by the running code. 

A memory leak can diminish the performance of the computer by reducing the amount of available memory. Eventually, in the worst case, too much of the available memory may become allocated and all or part of the system or device stops working correctly, the application fails, or the system slows down unacceptably due to thrashing.

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

}

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

1. 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.
2. The second cause is allocating the memory for unmanaged resources and then not releasing it after use. Whenever we are working with objects that are not collected by the garbage collector, we need to be extra careful to dispose of them after use. Otherwise, these will cause a memory leak as they are not cleaned up by the GC.

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.