What strategies and tools are useful for finding memory leaks in NET

Question

I wrote C   for 10 years  I encountered memory problems  but they could be fixed with a reasonable amount of effort   For the last couple of years I ve been writing C   I find I still get lots of memory problems  They re difficult to diagnose and fix due to the non-determinancy  and because the C  philosophy is that you shouldn t have to worry about such things when you very definitely do   One particular problem I find is that I have to explicitly dispose and cleanup everything in code  If I don t  then the memory profilers don t really help because there is so much chaff floating about you can t find a leak within all the data they re trying to show you  I wonder if I ve got the wrong idea  or if the tool I ve got isn t the best   What kind of strategies and tools are useful for tackling memory leaks in  NET

User · Answer

The best thing to keep in mind is to keep track of the references to your objects. It is very easy to end up with hanging references to objects that you don't care about anymore. If you are not going to use something anymore, get rid of it.

Get used to using a cache provider with sliding expirations, so that if something isn't referenced for a desired time window it is dereferenced and cleaned up. But if it is being accessed a lot it will say in memory.

User · Answer

I use Scitech s MemProfiler when I suspect a memory leak   So far  I have found it to be very reliable and powerful  It has saved my bacon on at least one occasion   The GC works very well in  NET IMO  but just like any other language or platform  if you write bad code  bad things happen

User · Answer

We ve used Ants Profiler Pro by Red Gate software in our project   It works really well for all  NET language-based applications     We found that the  NET Garbage Collector is very  safe  in its cleaning up of in-memory objects  as it should be    It would keep objects around just because we might be using it sometime in the future   This meant we needed to be more careful about the number of objects that we inflated in memory   In the end  we converted all of our data objects over to an  inflate on-demand   just before a field is requested  in order to reduce memory overhead and increase performance   EDIT  Here s a further explanation of what I mean by  inflate on demand    In our object model of our database we use Properties of a parent object to expose the child object s    For example if we had some record that referenced some other  detail  or  lookup  record on a one-to-one basis we would structure it like this   class ParentObject    Private mRelatedObject as New CRelatedObject    public Readonly property RelatedObject   as CRelatedObject       get          mRelatedObject getWithID RelatedObjectID           return mRelatedObject       end get    end property End class   We found that the above system created some real memory and performance problems when there were a lot of records in memory   So we switched over to a system where objects were inflated only when they were requested  and database calls were done only when necessary   class ParentObject    Private mRelatedObject as CRelatedObject    Public ReadOnly Property RelatedObject   as CRelatedObject       Get          If mRelatedObject is Nothing             mRelatedObject   New CRelatedObject          End If          If mRelatedObject isEmptyObject             mRelatedObject getWithID RelatedObjectID           End If          return mRelatedObject       end get    end Property end class   This turned out to be much more efficient because objects were kept out of memory until they were needed  the Get method was accessed    It provided a very large performance boost in limiting database hits and a huge gain on memory space

User · Answer

After one of my fixes for managed application I had the same thing  like how to verify that my application will not have the same memory leak after my next change  so I ve wrote something like Object Release Verification framework  please take a look on the NuGet package ObjectReleaseVerification  You can find a sample here https   github com outcoldman OutcoldSolutions-ObjectReleaseVerification-Sample  and information about this sample http   outcoldman ru en blog show 322

User · Answer

Big guns - Debugging Tools for Windows  This is an amazing collection of tools  You can analyze both managed and unmanaged heaps with it and you can do it offline  This was very handy for debugging one of our ASP NET applications that kept recycling due to memory overuse  I only had to create a full memory dump of living process running on production server  all analysis was done offline in WinDbg   It turned out some developer was overusing in-memory Session storage     If broken it is     blog has very useful articles on the subject

User · Answer

One of the best tools is using the Debugging Tools for Windows  and taking a memory dump of the process using adplus  then use windbg and the sos plugin to analyze the process memory  threads  and call stacks    You can use this method for identifying problems on servers too  after installing the tools  share the directory  then connect to the share from the server using  net use  and either take a crash or hang dump of the process    Then analyze offline

User · Answer

Just for the forgetting-to-dispose problem  try the solution described in this blog post   Here s the essence       public void Dispose                     Dispose logic here                 It s a bad error if someone forgets to call Dispose             so in Debug builds  we put a finalizer in to detect            the error  If Dispose is called  we suppress the            finalizer   if DEBUG         GC SuppressFinalize this    endif         if DEBUG      TimedLock                    If this finalizer runs  someone somewhere failed to            call Dispose  which means we ve failed to leave            a monitor          System Diagnostics Debug Fail  Undisposed lock           endif

User · Answer

one of the best tools I used its DotMemory you can use this tool as an extension in VS after run your app you can analyze every part of memory by Object  NameSpace  etc  that your app use and take some snapshot of that  Compare it with other SnapShots  DotMemory

User · Answer

I just had a memory leak in a windows service  that I fixed   First  I tried MemProfiler  I found it really hard to use and not at all user friendly   Then  I used JustTrace which is easier to use and gives you more details about the objects that are not disposed correctly   It allowed me to solve the memory leak really easily

User · Answer

Are you using unmanaged code   If you are not using unmanaged code  according to Microsoft  memory leaks in the traditional sense are not possible   Memory used by an application may not be released however  so an application s memory allocation may grow throughout the life of the application      From How to identify memory leaks in the common language runtime at Microsoft com      A memory leak can occur in a  NET   Framework application when you use   unmanaged code as part of the   application  This unmanaged code can   leak memory  and the  NET Framework   runtime cannot address that problem       Additionally  a project may only   appear to have a memory leak  This   condition can occur if many large   objects  such as DataTable objects    are declared and then added to a   collection  such as a DataSet   The   resources that these objects own may   never be released  and the resources   are left alive for the whole run of   the program  This appears to be a   leak  but actually it is just a   symptom of the way that memory is   being allocated in the program    For dealing with this type of issue  you can implement IDisposable   If you want to see some of the strategies for dealing with memory management  I would suggest searching for IDisposable  XNA  memory management as game developers need to have more predictable garbage collection and so must force the GC to do its thing   One common mistake is to not remove event handlers that subscribe to an object   An event handler subscription will prevent an object from being recycled   Also  take a look at the using statement which allows you to create a limited scope for a resource s lifetime

User · Answer

I prefer dotmemory from Jetbrains

User · Answer

You still need to worry about memory when you are writing managed code unless your application is trivial   I will suggest two things  first  read CLR via C  because it will help you understand memory management in  NET   Second  learn to use a tool like CLRProfiler  Microsoft    This can give you an idea of what is causing your memory leak  e g  you can take a look at your large object heap fragmentation

User · Answer

This blog has some really wonderful walkthroughs using windbg and other tools to track down memory leaks of all types   Excellent reading to develop your skills

User · Answer

If the leaks you are observing are due to a runaway cache implementation  this is a scenario where you might want to consider the use of WeakReference  This could help to ensure that memory is released when necessary   However  IMHO it would be better to consider a bespoke solution - only you really know how long you need to keep the objects around  so designing appropriate housekeeping code for your situation is usually the best approach

User · Answer

From Visual Studio 2015 consider to use out of the box Memory Usage diagnostic tool  to collect and analyze memory usage data    The Memory Usage tool lets you take one or more snapshots of the managed and native memory heap to help understand the memory usage impact of object types

[c#] What strategies and tools are useful for finding memory leaks in .NET?

Examples related to c#

Examples related to .net

Examples related to memory-management

Examples related to memory-leaks