One curious thing about C# is that it can use two different operators to calculate an and expression: the & operator and the && operator. The difference between both is that the first one (&) can be used both with integer types and boolean types. When used with integer types it will perform a bitwise comparison between the two, and when used with boolean values it will use the logical and operation between the two boolean values, evaluating all the parts of the expression. This means that using a code like this one:

if (someObject != null & someObject.SomeProperty == someValue)

will throw a runtime error if someObject is null, because it will try to obtain the SomeProperty value.

However, the && operator is only available to boolean expressions, and it uses lazy evaluation, this is, if the first condition evaluated is false, it will calculate false without evaluating the rest of the expression, because an and is only true if all the expressions are true.

Conclusion, be sure to always use &amp& when evaluating boolean values if you want to avoid run time surprises .

Cropped ComboBox

This is annoying because users cannot read properly the information. To solve that problem, all we have to do is derive the ComboBox class and override the DropDown event as follows:

public class ComboBoxEx : ComboBox
{
	public ComboBoxEx()
		: base()
	{
		DropDown += new EventHandler(event_DropDown);
	}
 
	void event_DropDown(object sender, EventArgs e)
	{
		try
		{
			ComboBox comboBox = (ComboBox)sender; // Catch the combo firing this event
			int width = comboBox.Width; // Current width for ComboBox
			Graphics g = comboBox.CreateGraphics(); // Get graphics for ComboBox
			Font font = comboBox.Font; // Doesn't change original font
 
			//checks if a scrollbar will be displayed.
			int vertScrollBarWidth;
			if (comboBox.Items.Count > comboBox.MaxDropDownItems)
			}
				//If yes, then get its width to adjust the size of the drop down list.
				vertScrollBarWidth = SystemInformation.VerticalScrollBarWidth;
			}
			else
			{
				//Otherwise set to 0
				vertScrollBarWidth = 0;
			}
			//Loop through list items and check size of each items.
			//set the width of the drop down list to the width of the largest item.
			int newWidth;
			foreach (string s in comboBox.Items)
			{
				if (s != null)
				{
					newWidth = (int)g.MeasureString(s.Trim(), font).Width + vertScrollBarWidth;
					if (width < newWidth)
						width = newWidth;
				}
			}
			// Finally, adjust the new width
			comboBox.DropDownWidth = width;
		}
		catch {  }
	}   
}

The following picture shows the results of using the above control instead of the default one:

Non Cropped ComboBox

So, what’s the matter with StringBuilders in C#?

It seems the same thing happens with Strings, C# and Java. Here is a copy paste from the MSDN web page about the StringBuilder usage:

The String object is immutable. Every time you use one of the methods in the System.String class, you create a new string object in memory, which requires a new allocation of space for that new object. In situations where you need to perform repeated modifications to a string, the overhead associated with creating a new String object can be costly. The System.Text.StringBuilder class can be used when you want to modify a string without creating a new object. For example, using the StringBuilder class can boost performance when concatenating many strings together in a loop.

So I decided to run some tests to see how much it was worth to change my code to use the StringBuilder class, because I use the string ‘+’ operator a lot in my program, and the results are simply amazing. Here you can find a chart comparing the times it took to concatenate a given number of strings using both methods. See for yourself and then… use StringBuilders from now on!

String usage

StringBuilder usage

Here’s the source code i used if you want to try it for yourself:

using System;
using System.Collections.Generic;
using System.Text;
 
using Adapdev.Diagnostics;
 
namespace SBuilder
{
    class Program
    {
        static void Main(string[] args)
        {
            HiPerfTimer timer = new HiPerfTimer();
            for (int i = 0; i < 100; i++)
            {
                StringBuilder sb = new StringBuilder();
                timer.Start();
                for (int j = 0; j < 1000 <strong> i; j++)
                {
                    sb.Append(j);
                }
                timer.Stop();
                double timeStringBuilder = timer.Duration;
 
                string s = string.Empty;
                timer.Start();
                for (int j = 0; j < 1000 </strong> i; j++)
                {
                    s += j;
                }
                timer.Stop();
                double timeString = timer.Duration;
 
                StringBuilder line = new StringBuilder();
                line.Append(1000 * i);
                line.Append(";");
                line.Append(timeStringBuilder);
                line.Append(";");
                line.Append(timeString);
                System.Console.WriteLine(line.ToString());
            }
        }
    }
}

You can download the external timer classes from The Code Project.

Today I’ll be discussing a design pattern called Double Check, which can be widely used to manage the resource access, elimination and initialization in a safe thread way.

Consider another common design pattern: the Singleton Pattern. A singleton is a special class which is allowed to have one and only one instance in a program. This pattern can be used in a variety of ways, one of the most usual one is to store global program information, which, as its name states, is global and unique to the application, so having more than one instance of that class would have the burden to mantain them synchronized, or even more nasty consequences.

There are different ways to implement a singleton class. I will focus on C#, but the example shown here could be easily extended to other languages such as C++ or Java. The trick on the pattern consists on declaring the class constructor private. This way we can be sure no one will be creating new instances of that class at will. After having done this, we have to provide a public method, which usually has the name getInstance, that will be the one actually creating this item and returning it to the caller.

The code would look similar to this one:

public sealed class Singleton
{
    private static Singleton instance = null;
 
    private Singleton(){}
 
    public static Singleton Instance
    {
        get
        {
            if (instance == null)
                instance = new Singleton();
            return instance;
        }
    }
}

Another way to create this singleton class would be doing the instantiation of the private variable on the class itself and not on the getInstance method, but this second way gives us a lazy initialization, so the variable is actually instantiated only when it’s needed, and never before (who knows, maybe we will never need it in some circumstances).

This implementation is perfect… as long as this method isn’t called twice (or more) at the same time. Consider what would happen if two threads requested an instance of the singleton class: both threads would check for the instance being null, and both threads would create the instance. That would sure lead to an unknown behaviour, and more than one instance of the class would be in the program, which is exactly what we wanted to avoid.

The first solution that comes in mind is to lock the method so multiple threads must wait to enter the method and get the singleton instance. It would look like this:

public sealed class Singleton
{
    private static Singleton instance = null;
    private static object sempahore = new Object();
 
    private Singleton(){}
 
    public static Singleton Instance
    {
        get
        {
            lock(semaphore);
            if (instance == null)
                instance = new Singleton();
            return instance;
        }
    }
}

This way we ensure that if n threads try to access the routine at the same time, only one will be initializing the singleton instance, since when the others gain the access to the method again, that instance won’t be null anymore. However, even if this solution is valid and works, it has a serious performance problem. Consider the situation where the instance has been already created. Then more than one thread access the routine again to get that instance. What will happen is that those threads will have to block and wait for other threads to finish, even if the instance is not null, so in any case will be created again. Conclusion: we are blocking threads that don’t need to be blocked. “Ok, you may say, we will put the lock inside the if clause, and we’ll have the issue resolved“. Let’s take a look at this solution:

public sealed class Singleton
{
    private static Singleton instance = null;
    private static object sempahore = new Object();
 
    private Singleton(){}
 
    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock(semaphore);
                instance = new Singleton();
            }
            return instance;
        }
    }
}

You don’t have to be a genious to see that this is not working, either. It will work after the instance has been created, because the threads won’t be entering the if clause, and they won’t be blocked. But if we are in the same situation as the described in the first place –this is, more than one thread entering the method before the instance has been created–, we have the same problem we had before: the singleton will be created more than once.

The final solution is simple: check again for the variable being null! This is why this pattern is called Double Check. The final code would look like this one:

public sealed class Singleton
{
    private static Singleton instance = null;
    private static object sempahore = new Object();
 
    private Singleton(){}
 
    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock(semaphore);
                if (instance == null)
                    instance = new Singleton();
            }
            return instance;
        }
    }
}

This way, we allow the threads to pass by the if clause if the instance has been already instantiated, and if it has not, the threads will get blocked, and the first one to gain access to the method will do the instantiation. Further threads will check again against the instance being null or not, so it won’t be created again.

Altough this pattern may be implemented similarly in other languages, be aware that, as I said before, a lot of them were never intended to deal with multithreading, and that compiler optimizations may give you code which is not really thread safe, or that actually is not optimized. Here you have a link discussing this issue with Java and C++: http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html.

Well, I want to introduce Ruby Quiz. It is a collection of minigames prepared to learn Ruby (or to improve your skills). Every week they publish one game, and if you are brave you can send your solution to them and it will be public. I think it’s one of the best ways to learn because you can compare solutions and find were you are weak in Ruby and redo your solution doing it smarter.

Here I post my .irbrc and to make things clear there are some explanations on each line.

# autocompletion of methods when pressing TAB
require 'irb/completion'
# Wirble is a plugin to colorize your irb, it's installed from a gem (gem install -y wirble)
require 'rubygems'
require 'wirble'
 
# Make use of readline library
ARGV.concat [ "--readline" ]
 
# autoindent of code while typing it
IRB.conf[:AUTO_INDENT]=true
 
# wirble initializations
Wirble.init
Wirble.colorize

As I said before, IRB is very powerful and a proof is that in Ruby Lang they encourage you to try ruby in your browser with an embedded IRB.

Also in rails the console for debugging your application is an irb instance preloaded with all rails configuration. In RailsCasts there is a screencast that shows you some tricks about it.

There’s a lot of documentation out there on how to design and specify application before the coding process starts, but there is a crucial factor on success that is not usually spoken of: the way you manage, create and edit your source files.

And of course there are some beautiful software pieces to help developers in that process. They’re called IDEs (Integrated Development Environment).

The problem with most of those IDEs is that they offer so many options that you usually have to read a user’s manual to really take the best from them. Ok, this is something normal, you might say. Maybe you’re right, but be honest, how many software user guides have you read in your life? And I’m not talking about the usual RTFM for a linux man page which can be 4 pages long at most. I’m talking about a user’s manual of 500 pages. I haven’t.

And that’s the reason today I’ll be talking about a nice feature I found on one of the most powerful IDEs out there (regardless of being from Microsoft): Visual Studio 2005 Code Snippets.

Code Snippets are more than just snippets of code, to start with. It’s not a simple code listing to quickly paste into your files, because Code Snippets are smart and adaptative, this is, they can be parametrized. Let’s see this in a simple example.

Imagine you want to code a for loop. All those kind of code structures behave the same way: there’s an initial condition, an ending condition, a condition modifier so you eventually leave the bucle, and of course the body, the code you want to be executed every time the bucle takes place. And it’s not unusual to use an integer variable to manage the counter which controls how many times that piece of code will be executed, for example the index of an array and the size of that array. You would code something like this:

int length = someArray.size();
 
for (int i = 0; i < length; ++i)
{
    doSomething(array[i]);
}

Ok, this is a shot piece of code and it takes about 10 seconds to write it, but it would be better if some IDE feature could help us. This is where Code Snippets come into action. Let’s do this exact thing using Code Snippiets.

1. Go to the part of the code you want to place the bucle in and press the right mouse button to select the Insert Snippet option.
2. Select the for on the list box.
3. You’ll see the basic structure of the code has already been typed for you.

Inserting a snippet

Inserting a snippet (2)

Inserting a snippet (3)

But this is not the end of the story!

With the tab key you can now navigate through the index variable and the ending condition of the bucle to type whatever you want there. Pressing enter will end the snippet wizard, and voilá, you have your for bucle coded, and only the body needs to be filled.

This example is kind of basic and you probably could code this far quicker by hand than by having to press mouse buttons and cursor arrows. You may be right, but as you may have already seen, there are plenty of snippets than can help you really improve your coding speed for all those “always the same” code structures. One good example of it is the property definitions on a C# class.

But code snippets not only can add code to a blank line, they can also sorround existing code to add features on it. Imagine you ‘ve started coding a method and you realize later that there is some kind of exception you should be dealing with. You know what that means, going to the upper part of the code, typing the try {, going down, close the bracket, and probably indenting the bracketed code to have a pretty printed code. Not to mention you should probably have to add a catch or finally clause after, too. This is work that can be tedious and it is not done in 10 seconds as a for bucle. Code Snippets can help us here too.

1. Select the code you want to sorround with a try/finally clause.
2. Click the right mouse button and select Sorround With.
3. Select the tryf snippet.

Sorrounding with snippets

Sorrounding with snippets (2)

Sorrounding with snippets (3)

One of the most interesting things about Code Snippets is that you can create your own for repetitive or tedious tasks you use to code. Let’s see how to proceed to create a custom Code Snippet.

To begin with, a Code Snippet is an XML file. It’s basic structure is the one following:

<codesnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <codesnippet format="1.0.0">
        <header>
 
        </header>
        <snippet>
            <code language="CSharp">
                <!--[CDATA[MessageBox.Show("Hello World");]]-->
            </code>
        </snippet>
    </codesnippet>
</codesnippets>

The element names are pretty self explanatory. You can customize the title of the snippet, and put the static code in a CDATA element, previously defining the language you’ll be using.

You can add Literals and Objects to the snippet code too. Literals are pieces of the snippet the programmer will usually want to replace, such as variable names and similar items. Objects are elements that the snippet needs but they usually are objects previously defined in your code that you want the snippet to use, such as specific objects to work with. You’ll understand this better with an example.

Let’s suppose you want to create a code snippet that checks a specific web request variable to validate against a custom SQL Injection class you’ve programmed. For simplicity’s sake we’ll suppose the validation class is already programmed and has a method that does this security feature. In this case, the literal could be the variable name of the web request, and the object could be the SQL Validator class instance you’ve previously defined in your code.

Both literals and objects are defined inside the Declarations node in the snippet XML as follows:

<declarations>
    <literal>
        <id>requestName</id>
        <tooltip>Replace with the variable name of the HTTP Request</tooltip>
        <default>action</default>
    </literal>
    <object>
        <id>SqlValidator</id>
        <type>MyProject.Data.Validation.SQLValidator</type>
        <tooltip>Replace with a SQLValidator object in your application.</tooltip>
        <default>sqlValidator</default>
    </object>
</declarations>

As you can see, you can define an identifier, a tooltip and a default value, and in the Object element the class of the object.

Now the only thing you have to do is replace in your code snippet the pieces of code where you want those literals and objects to appear like this:

<code language="CSharp">
        <!--[CDATA[
            string variableRequested = Request["$requestName$"];
            if (!$SQLValidator$.Validate(variableRequested))
            //Insert error handling here
        -->
</code>

So, the final snippet would look like this:

<codesnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <codesnippet format="1.0.0">
        <header>
 
        </header>
        <snippet>
            <declarations>
                <literal>
                    <id>requestName</id>
                    <tooltip>Replace with the variable name of the HTTP Request</tooltip>
                    <default>action</default>
                </literal>
                <object>
                    <id>SqlValidator</id>
                    <type>MyProject.Data.Validation.SQLValidator</type>
                    <tooltip>Replace with a SQLValidator object in your application.</tooltip>
                    <default>sqlValidator</default>
                </object>
            </declarations>
            <code language="CSharp">
                <!--[CDATA[
                    string variableRequested = Request["$requestName$"];
                    if (!$SQLValidator$.Validate(variableRequested))
                    //Insert error handling here
                    -->
            </code>
        </snippet>
    </codesnippet>
</codesnippets>

Now you just have to copy this snippet in your custom snippet folder (usually in Visual Studio 2005 folder created on My Documents) and you’ll be able to use it from the Visual Studio menu as any other one, or use the Code Snipper Manager on the Visual Studio Tools menu.

For more information about Code Snippets you can visit the MSDN page http://msdn2.microsoft.com/en-us/library/ms165393(VS.80).aspx.