Use of Switch instead of If whenever possible can be quite helpful, especially if its inside a loop or any code block which is executed frequently. It can give a performance boost up to 4 times !

Check out the sample skeleton code below and the performance readings for the same.

public void SwitchTest()

{

int i = 0;

while (LOOPCOUNT >= i++)

{

switch (i)

{

case 10:

break;

case 20:

break;

case 30:

break;

case 40:

break;

case 50:

break;

case 60:

break;

case 70:

break;

}

}

}

public void IfTest()

{

int i = 0;

while (LOOPCOUNT >= i++)

{

if (i == 10)

{

}

else if (i == 20)

{

}

else if (i == 30)

{

}

else if (i == 40)

{

}

else if (i == 50)

{

}

else if (i == 60)

{

}

else if (i == 70)

{

}

}

}

The above readings were generated with exact same code listed above and measured using DevPartner Performance expert. Its highly recommended that before applying any performance tips in your project, make sure to measure the performance yourself.

Writing If conditions

The way we write If conditions can dramatically affect the performance, especially if its in a loop churning out lot of data.

Check out following two sample code (the If conditions are meaningless and are just put to simulate some conditional processing)

public void IfNested()

{

int i = 0;

while (LOOPCOUNT >= i++)

{

if (i > 20)

{

if (i > 40)

{

if (i > 60)

{

}

}

}

}

}

public void IfCombined()

{

int i = 0;

while (LOOPCOUNT >= i++)

{

if (i > 20 && i > 40 && i > 60)

{

}

}

}

Out of the above two, combined condition is a winner as it benefits from conditional short circuiting optimization in .net. It’s also always a good move to put such conditions first in order which can help the runtime to skip executing unnecessary code blocks in advance.

If( CondA && CondB && CondC) is a good one if we know that CondA can be false most of the times. If CondC is the one which can be false most of the times, the if block should be written as If( CondC && CondB && CondA).

The above readings were generated with exact same code listed above and measured using DevPartner Performance expert. Its highly recommended that before applying any performance tips in your project, make sure to measure the performance yourself.

String or StringBuilder?

Which is better string or StringBuilder? We all know that StringBuilder is the better choice. Really? If yes, then by what ratio.

Let’s check it out.

We have following code blocks which perform exactly same, but are written in different ways

private const int LOOPCOUNT = 1000;

private void StringBuilderAppend()

{

StringBuilder _subElementValue = new StringBuilder();

int i = 0;

while (i++ <= LOOPCOUNT)

{

_subElementValue.Append(“_xmlStart”);

_subElementValue.Append(“nav3Name”);

_subElementValue.Append(“_xmlEnd”);

_subElementValue.Append(“nav3.Value”);

_subElementValue.Append(“_xmlEndStart”);

_subElementValue.Append(“nav3Name”);

_subElementValue.Append(“_xmlEnd”);

}

}

private void StringConcatenate()

{

int i = 0;

string sTemp = “”;

while (i++ <= LOOPCOUNT)

{

sTemp += “_xmlStart”;

sTemp += “nav3Name”;

sTemp += “_xmlEnd”;

sTemp += “nav3.Value”;

sTemp += “_xmlEndStart”;

sTemp += “nav3Name”;

sTemp += “_xmlEnd”;

}

}

As expected code block using StringBuilder.Append is quite fast compared to the string += operations. It’s 347 times faster than the string += operations! It’s a clear choice when concatenating multiple strings. What if we need the fastest code to be a little faster without killing the code readability and jumping into unsafe codes?

The following code is much faster than the StringBuilderAppend method. It’s faster by a factor of 2.4 times. What we simply did was used multiple string + operations (note there is no +=) and appended it in a StringBuilder.

private void StringBuilderAndStringConcatenate()

{

StringBuilder _subElementValue = new StringBuilder();

int i = 0;

while (i++ <= LOOPCOUNT)

{

_subElementValue.Append(“_xmlStart” + “nav3Name” + “_xmlEnd” + “nav3.Value” + “_xmlEndStart” +

“nav3Name” + “_xmlEnd”);

}

}

The above readings were generated with exact same code listed above and measured using DevPartner Performance expert. Its highly recommended that before applying any performance tips in your project, make sure to measure the performance yourself.

This was a setback and now I was in a fix. Either I have to explore new profiling tools to get my job done or dive into the vast code and find the issue. I decided to spend some time on finding if there is some other way to profile the windows services using DevPartner. I Googled a lot and could not find anything

Later out of frustration I looked into the installation directory, and found lots of exe’s and out of curiosity I opened them one by one. To my pleasant surprise I found one exe named DPAnalysis.exe which was what I wanted. It was a command line tool for doing all sorts of Analysis

• Performance
• Coverage
• Memory
• Performance expert

Following is the help output from that exe, which explains all the different command line arguments.

Usage:

1) DPAnalysis [a] [b] [c] [d] {e} target [target args]

2) DPAnalysis /config config.xml

a) AnalysisType: Set the run-time analysis type. Performance is default.

/PERF[ORMANCE] Set analysis type to DevPartner Performance Analysis

/COV[ERAGE] Set analysis type to DevPartner Coverage Analysis

/MEM[ORY] Set analysis type to DevPartner Memory Analysis

/EXP[ERT] Set analysis type to DevPartner Performance Expert

b) DataCollection: Enable/Disable data collection for a given target. DOES NOT LAUNCH the target.

/E[NABLE] Enable data collection for the specified process or service

/D[ISABLE] Disable data collection for the specified process or service

c) OtherOptions:

/O[UTPUT] Specify the session file output directory and/or name with optional extension (.dpprf, .dpcov, .dpmem, or .dppxp)

/W[ORKINGDIR] Specify the process’ working directory

/H[OST] Specify target’s host machine

/NOWAIT Don’t wait for process to exit, just wait for it to start

/N[EWCONSOLE] Run the process in its own command window

d) AnalysisOptions:

/NO_MACH5 Disables excluding time spent on other threads

/NM_METHOD_GRANULARITY Set data collection granularity to method-level (line-level is default)

/EXCLUDE_SYSTEM_DLLS Exclude data collection for system dlls (Perf only)

/NM_ALLOW_INLINING Enable run-time instrumentation of inline methods

/NO_OLEHOOKS Disable collection of COM

/NM_TRACK_SYSTEM_OBJECTS Track system object allocation (Memory only)

e) TargetType: Identify target process or service. MUST BE LAST OPTION.

All arguments after the target name/path are passed directly to the target.

/P[ROCESS] Target is an exe filename (followed by arguments to the process)

/S[ERVICE] Target is a service name (followed by arguments to the service)

2)/C[ONFIG] Path to configuration file that includes all startup information Note: no other options can be used with /Config

For profiling the windows service I used the following command”

DPAnalysis /MEM /E /S “my service name”

After running the above using a command prompt, I started the service from service controller, and let the service do its job. I monitored the memory usage and VM Size of service using task manager, and when I was convinced that the memory leak condition is reached, I stopped the service. I was prompted for saving the memory analysis file J, which could be easily opened up in VS2005 (of course because DevPartner was installed)

Consider the following class code snippet.

public class ThreadTest

{

Thread thSettingsMonitor = null;

bool _stopTimeOutProcessing = false;

public override string ToString()

{

return “Thread running state is : “ + this._stopTimeOutProcessing.ToString();

}

public void Start()

{

thSettingsMonitor = new Thread(new ThreadStart(ReloadSettings));

thSettingsMonitor.Start();

Debug.WriteLine(“~~~ Starting the thread. Hash code: “ + this.GetHashCode().ToString());

}

public void Stop()

{

try

{

//set the variable so that the loop breaks and thread terminates

_stopTimeOutProcessing = true;

}

catch { }

}

private void ReloadSettings()

{

while (!_stopTimeOutProcessing)

{

try

{

//do some operation in the thread

//Mimic by a sleep of 2 seconds

Thread.Sleep(2000);

//wait for 5 minutes

Debug.WriteLine(“~~~ reload thread waiting on sleep for 5 min. Hash code: “ + GetHashCode().ToString());

Thread.Sleep(30000);

Debug.WriteLine(“~~~ Sleep period completed”);

}

catch (Exception ex)

{

Debug.WriteLine(ex);

}

}

}

}

Now in a windows application form write the following code

private ThreadTest othTest = new ThreadTest();

private void button1_Click(object sender, EventArgs e)

{

//Start the reloadsettings thread

othTest.Start();

}

private void FrmTest_FormClosing(object sender, FormClosingEventArgs e)

{

othTest.Stop();

}

Run the code, click on the button so that the thread starts running. Try closing the form. Note that the form closes but the .net IDE does not breaks until some time. This means that some code is still executing. Click on the pause button of .net IDE to see which code is running. You will notice that the thread code Thread.Sleep(30000); is still executing.

Now try the updated code.

public class ThreadTest

{

Thread thSettingsMonitor = null;

bool _stopTimeOutProcessing = false;

private EventWaitHandle _exitEvent = new EventWaitHandle(false, EventResetMode.ManualReset);

public override string ToString()

{

return “Thread running state is : “ + this._stopTimeOutProcessing.ToString();

}

public void Start()

{

thSettingsMonitor = new Thread(new ThreadStart(ReloadSettings));

thSettingsMonitor.Start();

Debug.WriteLine(“~~~ Starting the thread. Hash code: “ + this.GetHashCode().ToString());

}

public void Stop()

{

try

{

//set the variable so that the loop breaks and thread terminates

_stopTimeOutProcessing = true;

if (_exitEvent != null)

{

Debug.WriteLine(“~~~ Signalling the timeout thread. Hash code: “ + this.GetHashCode().ToString());

_exitEvent.Set();

Debug.WriteLine(“~~~ Signalling the timeout thread done. Hash code: “ + this.GetHashCode().ToString());

}

}

catch { }

}

private void ReloadSettings()

{

while (!_stopTimeOutProcessing)

{

try

{

//do some operation in the thread

//Mimic by a sleep of 2 seconds

Thread.Sleep(2000);

//wait for 5 minutes

Debug.WriteLine(“~~~ reload thread waiting on eventwait object for 5 min. Hash code: “ + GetHashCode().ToString());

_exitEvent.WaitOne(300000, true);

Debug.WriteLine(“~~~ done waiting or the eventwait object was signaled”);

}

catch (Exception ex)

{

Debug.WriteLine(ex);

}

}

}

}

Run the code and note the difference. This time the application closes immediately.

Let’s understand what was different.

private EventWaitHandle _exitEvent = new EventWaitHandle(false, EventResetMode.ManualReset);

Here we created a thread synchronization object with initial state as non signaled and mode as manual.

Instead of Thread.Sleep(2000); we have now used _exitEvent.WaitOne(300000, true); this instructs the thread to wait for 5 minutes (30000 msec) and exit the wait before the time is elapsed if the event object is signaled.

During form close we have used _exitEvent.Set();. This code signals the event object. When the event object is signaled the thread comes out of wait immediately even before the wait time is completed. The EventWaitHandle is a versatile object when it comes to thread synchronization. Explore it if you are writing multi threaded applications.

PS: The above problem can be easily worked out in normal scenario by setting the thread as a background thread. The only problem it will have is it will be aborted immediately during application close.

Happy coding!

The .net debugger calls the ToString() automatically on the instance which is to be monitored in the watch window. If we override the ToString() implementation in our class and provide the key fields as part of implementation, that will make our job a lot easier when it comes to debugging.

See the following code listing. Run it with the ToString() method commented and add a instance of the clsExample class nin watch window and notice the data. Compare it with the original verison.

using System.Diagnostics;

namespace DebuggererAttribute

{

public class clsExample

{

private int _FieldOne;

private double _FieldTwo;

private string _FieldThree;

private bool _FieldFour;

public int FieldOne

{

get

{

return _FieldOne;

}

set

{

_FieldOne = value;

}

}

public double FieldTwo

{

get

{

return _FieldTwo;

}

set

{

_FieldTwo = value;

}

}

public string FieldThree

{

get

{

return _FieldThree;

}

set

{

_FieldThree = value;

}

}

public bool FieldFour

{

get

{

return _FieldFour;

}

set

{

_FieldFour = value;

}

}

public override string ToString()

{

return string.Format(“FieldOne = {0}, FieldTwo = {1}, FieldThree = {2}, FieldFour = {3}”, _FieldOne, _FieldTwo, _FieldThree, _FieldFour);

}

public clsExample()

{

_FieldOne = 2;

_FieldTwo = 3.66;

_FieldThree = “This is some text”;

_FieldFour = true;

}

}

}

I was accustom to see this dialog when a COM server is busy or is waiting for some resource and usually after some time, Switching or Retrying worked.

Fortunately i got this error on my development machine once and more fortunately i was running a debug build. I paused the program and watched the call stack. The program was waiting on a thread which was in a “Wait or Sleep/Join state”. Drilling down more on the thread, it was found that it was one of the our own application thread.

This information gave me a good deal of information on where to look for. I checked the module which created the thread and found that it was created in a user control and the thread was using a AutoResetEvent object. The wait state of the thread as i discovered earlier from call stack was from the Dispose call of the user control. I checked the code to see the places where the AutoResetEvent was closed or signaled. Well the object was not cleaned up/closed in the Dispose call “which was the problem”.

The thread was waiting on the AutoResetEvent object and was not allowing the user control to Dispose and hence the application to close.

Learning:
1. Clean up all variables manually, don’t rely on GC. GC does a good job, but we screw up our selves thinking GC will take care.
2. Use of thread and windows kernel objects like Mutex, Semaphores etc (thread synch objects) are a double edged sword. Always use them with caution.

I was relaxed to see that the memory usage in task manager rose by just 20K -30 K on each thread creation with an exception that the first thread creation increased the memory by around 1 MB.

Later I started checking Virtual memory usage as well and was shocked to see 1 MB of memory usage on each thread creation! A little goggling revealed that by default each thread is assigned a 1 MB stack! Check out the sample code which prints out the Virtual Memory usage of the test application in debug window on each thread creation.

//code
private static void Somethread()
{
Debug.WriteLine(string.Format(“Started thread with thread id {0}”, Thread.CurrentThread.ManagedThreadId));
//Print task managers VM Size column
Debug.WriteLine(string.Format(“Current VM usage is {0} MB”, (Process.GetCurrentProcess().PagedMemorySize64 / (1024 * 1024))));

Thread.Sleep(1000 * 60 * 1); // let the thread live for some time while we create some more threads
Debug.WriteLine(string.Format(“—-Ended thread with thread id {0}”, Thread.CurrentThread.ManagedThreadId));

//Print task managers VM Size column
Debug.WriteLine(string.Format(“Current VM usage is {0} MB”, (Process.GetCurrentProcess().PagedMemorySize64 / (1024 * 1024))));

}

private void btnCreateThread_Click(object sender, EventArgs e)
{
//Each created thread will be allocated 1 MB of Virtual memory
Thread samplethread = new Thread(Somethread);
samplethread.IsBackground = true;
samplethread.Start();
}

Conclusion: Want to keep a small footprint of the application, think twice before creating a new thread.