Reader Level:
ARTICLE

Debugging Techniques in C#

Posted by Mike Borromeo Articles | Coding Best Practices December 04, 2001
Debugging GUI applications for me mostly consists of printing out debug statements in the form of a dialog box with some text.
  • 1
  • 0
  • 40980
 

Debugging GUI applications for me mostly consists of printing out debug statements in the form of a dialog box with some text. While this technique was helpful for small to medium size apps I find writing large apps with a dialog box popping up after every other statement is counterproductive. With this in mind, I set out to find a better method for displaying debug statements during runtime. Enter C#. 

C# solves three problems I faced when designing the useful and scalable debugging system. These problems exist either in Java, C/C++, or both (my main programming languages).  

  1. Not having very much meta-information (e.g. line number, method name, etc.).
  2. Having to add and remove debug statements whenever the debug focus shifts.
  3. Having the debug statements compiled into the program affecting performance.

Ok, discussing the solution for these problems in order well start with number one. Basically a few classes from the System.Reflection and System.Diagnostics namespaces solve this problem. Using the System.Diagnostics.StackFrame class the call stack can be explored and stack details such as what is on the stack level above the current one, what line is a function being called from, etc. And with the System.Reflection classes the names of functions, namespaces, variable types, etc., can be ascertained. Applying all this to the problem at hand heres some code that retrieves the file name, line number, and method name of the function that called it. 

// create the stack frame for the function that called this function
StackFrame sf = new StackFrame( 1, true );
// save the method name
string methodName = sf.GetMethod().ToString();
// save the file name
string fileName = sf.GetFileName();
// save the line number
int lineNumber = sf.GetFileLineNumber();

Moving right along to problem number two lets discuss how to selectively debug different sections of a program during runtime. Number two ties in with number one in that information from number one will help us filter debug statements from being displayed. For this example well filter by namespace. So say that you have fifteen namespaces in your program and right now you only want to display debug statements from one all you would have to do is tell the debug class only allow that one namespace to display debug statements. Simple enough. Heres some code. 

// create the namespaces hashtable
namespaces = new Hashtable();
// get the assembly of this class
Assembly a = Assembly.GetAssembly( new Debug().GetType() );
// now cycle through each type and gather up all the namespaces
foreach( Type type in a.GetTypes() )
{
// check if the namespace is already in our table
if( ! namespaces.Contains( type.Namespace ) )
namespaces.Add( type.Namespace,
true );
}

The above code will create a Hashtable object containing all the namespaces in the same assembly as the Debug class of which this code is a part. Of course, this is only half of the solution so here is the actual filtering code.

// only proceed if the namespace in question is being debugged
if( (bool) namespaces[ method.DeclaringType.Namespace ] )
// this is where the debug statement display code would be

Ok, so far so good. With the problems number one and two knocked out that leaves us with the obstacle of removing those darn debug statements when the final release is to be made without actually having to manually comment out or delete each one. This is where those handy little things called attributes come in to play. Assuming you have knowledge of how attributes work in C# Ill cut to the chase and introduce the ConditionalAttribute which is part of the aforementioned System.Diagnostics namespace. So heres some showing how to use the ConditionalAttribute class. 

[Conditional("DEBUG")]
public void Debug( string msg )
{
// this is where the debug statement display code would be
}

What this will do is when this program is compiled it will check if DEBUG was #defined and if it was then the call to this function will be remain, however if DEBUG is not #defined all calls to this function not will be compiled leaving us with no performance hit. 

Now, some of you are probably saying that you could solve some of the problems above in C/C++ and Java. I will note that neither language solves all of them. For example in C/C++ you can #define and #ifdef much like you can use ConditionalAttribute class and C# defines. But getting useful meta-information in C/C++ is limited. And in Java getting meta-information is possible but as far as I know all the code is always compiled (i.e. theres no Conditional type functionality). Thankfully there is C# which does solve (gracefully I might add) all the problems I mentioned above and quite a few more. 

To demonstrate these techniques I wrote a small windows application along with this article. The Debug class can be plugged into your own projects.

So enjoy and happy coding.

COMMENT USING

Trending up