magazine®

    <Declarations>       <Literal default="true">         <ID>name</ID>         <ToolTip>Class name</ToolTip>         <Default>MyClass</Default>       </Literal>     </Declarations>   The snippet contains one parameter which is the “Class name”. You can specify as many parameters as you want.

• <Code> - this tag contains the specific code to insert. Let’s see the example:

   <Code Language="csharp" Format="CData">     <![CDATA[class $name$     {       $selected$$end$     }]]>    </Code> By looking at the code, you’ll notice three different-looking directives. The $name$, $selected$ and $end$. The $name$ directive is the ID of the parameter that you declared in the <Declarations> tag. This will tell the IDE that this is the place where the user must specify a value. The $selected$ directive represents the code that was selected prior to the insertion of the code snippet. This is pretty useful if your snippet will supports “SurroundsWith”. Lastly the $end$ directive is where your cursor would be located after the insertion of the code snippet.

Visual Studio 2005 offers a great IDE for improving your coding speeds. One if the feature that would definitely boost your speed up is the Code Snippet.

Code Snippets are pieces of code that you can automatically insert in your source code to avoid redundant coding.

To insert code snippets on your code, simply right-click on the editor and choose insert snippet.

You will then be prompted to choose from the library of snippets that you have. If you’re asking on how you could create your own directory of snippets, I’ll be discussing it on a seperate article.

After choosing the snippet library you will then get the list of available snippets for that library. Lets try selecting the “for” snippet.

By selecting a snippet, a code then is automatically generated. Plus the generated code would highlight the thing that needs editing.

Another cool feature of code snippets is its ability to wrap your code with a snippet. For example you have this code:

DataTable dt = new DataTable();
dt.Columns.Add("Col1");
dt.Columns.Add("Col1");
DataRow dr = dt.NewRow();
...

And then you realize that you must place this in a reverse for-loop. You can do it easily by using “Surround With”. To do this, just highlight the code, then right click and select “Surround With”

Just like using code-snippets, you’ll also be prompted to select the code-snippet to wrap this code.

Let’s try selecting a reverse for-loop.

Voila! Your code now is wrapped with a reverse for-loop statement.

I had just a run-in-review with this feature when my friend asked me how to enable your class to contain “angle bars []” to return a value from his class, much like an array. Well, the proper way of doing this is to use Indexers in your class.

Indexers works internally like a property. You need to specify its get and set routines to retrieve and give values to your indexed class. Here’s a sample to give you a clearer image on what I’m saying:

class IndexerClass{
    private int[] arr = new int[100];
    public int this[int index]   // Indexer declaration {
        get {
            // Check the index limits.
            if (index < 0 || index >= 100) {
                return 0;
            } else {
                return arr[index];
            }
        } set {
            if (!(index < 0 || index >= 100)) {
                arr[index] = value;
            }
        }
    }
}

class MainClass {
    static void Main() {
        IndexerClass test = new IndexerClass();
        // Call the indexer to initialize the elements #3 and #5.
        test[3] = 256;
        test[5] = 1024;
        for (int i = 0; i <= 10; i++) {
            System.Console.WriteLine("Element #{0} = {1}", i, test[i]);
        }
    }
}

Note: sample taken from the MSDN documentation.

The highlighted text in the sample shows you how you declare an Index in your class. It’s pretty quite self-explanatory. For reasons of to be able to make this blog longer, I’ll explain some bits on the code.

The first you’ll notice is the use of the this keyword. The this keyword indicates the current class that you are in, you must use the this keyword to specify a property-like index in your class. The second is the angle brackets, here you’ll specify the index itself. In the example, it uses an integer as an index. Well, virtually you can specify any type that you want inside your index. It can be a string or a double. The third part that you’ll notice is the get and set routine. As I explained earlier it works just like a property. The get routine specifies whenever the user gets the value of your index. The set routine enables you to trap whenever the user gives a value to your index. In your set routine, you would notice another keyword, the value keyword. This variable contains the value that the user is giving to your indexed class.

indexerClass[0] = “test” // the value variable would contain “test”

Well I guess that’s all the essential part of indexed class.

You might be wondering on what practical use indexed class would be. Well, for starters, it would be very useful if you would have dynamic properties. Instead of exposing a getValue() function, its more readable and easier if you’ll provide an index to your class. A perfect example of this is the DataReader and DataRow class of ADO .Net. It uses indexes to access values in your fields in a row in the database.

SqlDataReader reader = command.ExecuteReader();
int empId = (int) reader[“Id”];

Happy Indexing!