C# How to dump all variables & current values during runtime

Are there any in-built or 3rd party libraries that allow you to simply dump all variables in memory during run time? What I would 开发者_JAVA技巧like is to be able to view variables & current values similarly to viewing them by hitting a break point and hovering over variables, but without actually having to halt the program execution (i.e. just get a snapshot). Would be good if it could dump them to a file which can then be opened later in a program to get a nice GUI interface to view them, but simple text file dump would be good enough.

I can't think of an easy way to do this in a generic fashion. What could work is programmatically creating a dump file of your running process. You could either do this with P/Invoke to the dbghelp.dll routines or spawn a cdb.exe process to create the dump file. Once you have the file, you could open it up in a debugger for later analysis using SOS.dll with cdb.exe/windbg.exe, or even write a debugger script to dump the data you want (mostly) automatically.

I believe some sort of logging framework would help you to do that...

Check out:

http://www.dotnetlogging.com/

At my workplace we use log4net which works pretty well for us.

So how come you're wanting to dump out all the variables for later analysis? Have you considered writing your code test first so that you can reduce your reliance on the debugger and have a suite of automated test checking the values for you?

In the past I've used the YourKit .Net profiler in order to profile .Net applications.

While I've only ever used it to connect to running applications personally the Snapshot documentation does state that they have a Profiler API that can be used to programmatically dump snapshots for later review.

Code wise this looks to be as simple as the following:

Controller c = new Controller();
String snapshotPath = c.CaptureSnapshot();

I believe you can then load the snapshot files into the YourKit GUI at a later date to review them.

I would not be surprised if some of the other popular profilers like JetBrains dotTrace Performance and RedGates ANTS Performance Profiler have similar programmatic APIs but I couldn't quickly find obvious documentation on their websites (and I didn't want to watch their webinars to find out if this feature existed!)

For this you can use WMemoryProfiler to

• Get all objects in all appdomains as an object array
• Create a memory dump of your own process
• Serialize specific objects to disc

To make this happen you need Windbg of course but the Api of WMemoryProfiler is fully managed and you can basically self debug your process. The library takes care of the usual debugger oddities since it does wrap Windbg in a nice accessible library.

The code below does get all instances of System.Threading.Thread objects into an object array. This way you can write a visualizer for your own application objects at runtime. The other overload does simply give you all objects in all AppDomains.

using (var debugger = new MdbEng())
{
  var dummy = new Thread(() => {});
  dummy.Name = "Dummy Thread";

  // Get all thread objects in all AppDomains
  var threads = debugger.GetObjects("System.Threading.Thread", true);

  foreach (Thread t in threads)
  {
    Console.WriteLine("Managed thread {0} has Name {1}", t.ManagedThreadId, t.Name);
  }
  GC.KeepAlive(dummy);
}

Since it is a wrapper around Windbg you can also create a memory dump on the fly and later load a memory dump from your process to extract object data for visualization from the dump. Commerical Memory Profilers (e.g. MemoryProfiler from Scitech) employ this technique since years but it is quite slow when you have a huge memory dump since they are using also Windbg as dump analyzer.

You can try Intellitrace tool provided with ultimate version of visual studio. It is what you describe - it records what is happening in your app and allows you to debug it without executing your program with hovering over variables and all other debug windows to help you.

You can use PostSharp . I found it very useful to record debug times because of the environment application was deployed. And instrumented/recorded many things.

But obviously you'll need to specify all variables you need to record.

Check more details here.